Changeset 6f2edc in git for Singular/LIB/matrix.lib


Ignore:
Timestamp:
Apr 28, 1997, 9:27:25 PM (27 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'd1b01e9d51ade4b46b745d3bada5c5f3696be3a8')
Children:
8c5a578cc8481c8a133a58030c4c4c8227d82bb1
Parents:
6d09c564c80f079b501f7187cf6984d040603849
Message:
Mon Apr 28 21:00:07 1997  Olaf Bachmann
<obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>

     * dunno why I am committing these libs -- have not modified any
       of them


git-svn-id: file:///usr/local/Singular/svn/trunk@205 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/matrix.lib

    r6d09c56 r6f2edc  
    1 // $Id: matrix.lib,v 1.1.1.1 1997-04-25 15:13:26 obachman Exp $
    2 //(GMG+BM)
     1// $Id: matrix.lib,v 1.2 1997-04-28 19:27:22 obachman Exp $
     2// (GMG/BM, last modified 22.06.96)
    33///////////////////////////////////////////////////////////////////////////////
    4 LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS                         
     4LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
    55
    66 compress(A);           matrix, zero columns from A deleted
    … …  
    99 dsum(A1,A2,..);        matrix, direct sum of matrices A1,A2,...
    1010 flatten(A);            ideal, generated by entries of matrix A
     11 genericmat(n,m[,id]);  generic nxm matrix [entries from id]
    1112 is_complex(c);         1 if list c is a complex, 0 if not
    1213 outer(A,B);            matrix, outer product of matrices A and B
    1314 skewmat(n[,id]);       generic skew-symmetric nxn matrix [entries from id]
    14  submat(A,r,c);         submatrix of A with rows/cols specified by intvec r/c 
     15 submat(A,r,c);         submatrix of A with rows/cols specified by intvec r/c
    1516 symmat(n[,id]);        generic symmetric nxn matrix [entries from id]
    1617 tensor(A,B);           matrix, tensor product of matrices A nd B
    … …  
    3233
    3334proc compress (A)
    34 USAGE:   compress(A); A matrix/intmat/ideal/module
    35 RETURN:  matrix/intmat/ideal/module, zero columns/generators from A deleted
     35USAGE:   compress(A); A matrix/ideal/module/intmat/intvec
     36RETURN:  same type, zero columns/generators from A deleted
     37         (in an intvec zero elements are deleted)
    3638EXAMPLE: example compress; shows an example
    3739{
    38    if( typeof(A)=="matrix" ) { return(matrix(simplify(A,2))); } 
    39    if( typeof(A)=="intmat" )
     40   if( typeof(A)=="matrix" ) { return(matrix(simplify(A,2))); }
     41   if( typeof(A)=="intmat" or typeof(A)=="intvec" )
    4042   {
    4143      ring r=0,x,lp;
    42       module m=module(matrix(A));
    43       int c= size(m);
    44       intmat B[nrows(A)][c];
     44      if( typeof(A)=="intvec" ) { intmat C=transpose(A); kill A; intmat A=C; }
     45      module m = matrix(A);
     46      intmat B[nrows(A)][size(m)];
    4547      int i,j;
    46       for( i=1; i<=ncols(A); i++ )
    47       { 
    48          if( m[i]!=[0] ) 
    49          { 
     48      for( i=1; i<=ncols(A); i=i+1 )
     49      {
     50         if( m[i]!=[0] )
     51         {
    5052            j=j+1;
    5153            B[1..nrows(A),j]=A[1..nrows(A),i];
    5254         }
    5355      }
     56      if( defined(C) ) { return(intvec(B)); }
    5457      return(B);
    5558    }
    … …  
    6669   intmat B[3][4]=1,0,3,0,4,0,5,0,6,0,7,0;
    6770   compress(B);
     71   intvec C=0,0,1,2,0,3;
     72   compress(C);
    6873}
    6974////////////////////////////////////////////////////////////////////////////////
    7075proc concat (list #)
    71 USAGE:   concat(A1,A2,..); A1,A2,... matrices 
    72 RETURN:  matrix, concatenation of A1,A2,... . Number of rows of result matrix is 
     76USAGE:   concat(A1,A2,..); A1,A2,... matrices
     77RETURN:  matrix, concatenation of A1,A2,... . Number of rows of result matrix is
    7378         max(nrows(A1),nrows(A2),...)
    7479EXAMPLE: example concat; shows an example
    … …  
    7681   int i;
    7782   module B=module(#[1]);
    78    for( i=2; i<=size(#); i++ ) { B=B,module(#[i]); }
     83   for( i=2; i<=size(#); i=i+1 ) { B=B,module(#[i]); }
    7984   return(matrix(B));
    8085}
    … …  
    9297
    9398proc diag (list #)
    94 USAGE:   diag(p,n); p poly, n integer 
     99USAGE:   diag(p,n); p poly, n integer
    95100         diag(A);   A matrix
    96101RETURN:  diag(p,n): diagonal matrix, p times unitmatrix of size n
    97          diag(A)  : n*mxn*m diagonal matrix with entries all the entries of  the
     102         diag(A)  : n*mxn*m diagonal matrix with entries all the entries of the
    98103                    nxm matrix A, taken from the 1st row, 2nd row etc of A
    99104EXAMPLE: example diag; shows an example
    … …  
    104109      int i; ideal id=#[1];
    105110      int n=ncols(id); matrix A[n][n];
    106       for( i=1; i<=n; i++ ) { A[i,i]=id[i]; }
     111      for( i=1; i<=n; i=i+1 ) { A[i,i]=id[i]; }
    107112   }
    108113   return(A);
    … …  
    118123////////////////////////////////////////////////////////////////////////////////
    119124
    120 proc flatten (matrix A)
    121 USAGE:   flatten(A); A matrix
    122 RETURN:  ideal, generated by all entries from A
    123 EXAMPLE: example flatten; shows an example
    124 {
    125    return(ideal(A));
    126 }
    127 example
    128 { "EXAMPLE:"; echo = 2;
    129    ring r=0,(x,y,z),ds;
    130    matrix A[3][3]=1,2,3,x,y,z,7,8,9;
    131    print(A);
    132    flatten(A);
    133 }
    134 ////////////////////////////////////////////////////////////////////////////////
    135 
    136125proc dsum (list #)
    137 USAGE:   dsum(A1,A2,..); A1,A2,... matrices 
     126USAGE:   dsum(A1,A2,..); A1,A2,... matrices
    138127RETURN:  matrix, direct sum of A1,A2,...
    139128EXAMPLE: example dsum; shows an example
    … …  
    141130   int i,N,a;
    142131   list L;
    143    for( i=1; i<=size(#); i++ ) { N=N+nrows(#[i]); }
    144    for( i=1; i<=size(#); i++ )
    145    { 
    146       matrix B[N][ncols(#[i])]; 
     132   for( i=1; i<=size(#); i=i+1 ) { N=N+nrows(#[i]); }
     133   for( i=1; i<=size(#); i=i+1 )
     134   {
     135      matrix B[N][ncols(#[i])];
    147136      B[a+1..a+nrows(#[i]),1..ncols(#[i])]=#[i];
    148137      a=a+nrows(#[i]);
    … …  
    162151   print(dsum(A,B,C));
    163152}
     153////////////////////////////////////////////////////////////////////////////////
     154
     155proc flatten (matrix A)
     156USAGE:   flatten(A); A matrix
     157RETURN:  ideal, generated by all entries from A
     158EXAMPLE: example flatten; shows an example
     159{
     160   return(ideal(A));
     161}
     162example
     163{ "EXAMPLE:"; echo = 2;
     164   ring r=0,(x,y,z),ds;
     165   matrix A[3][3]=1,2,3,x,y,z,7,8,9;
     166   print(A);
     167   flatten(A);
     168}
     169////////////////////////////////////////////////////////////////////////////////
     170
     171proc genericmat (int n,int m,list #)
     172USAGE:   genericmat(n,m[,id]);  n,m=integers, id=ideal
     173RETURN:  nxm matrix, with entries from id (default: id=maxideal(1))
     174NOTE:    if id has less than nxm elements, the matrix is filled with 0's,
     175         genericmat(n,m); creates the generic nxm matrix
     176EXAMPLE: example genericmat; shows an example
     177{
     178   if( size(#)==0 ) { ideal id=maxideal(1); }
     179   if( size(#)==1 ) { ideal id=#[1]; }
     180   if( size(#)>=2 ) { "// give 3 arguments, 3-rd argument must be an ideal"; }
     181   matrix B[n][m]=id;
     182   return(B);
     183}
     184example
     185{ "EXAMPLE:"; echo = 2;
     186   ring R=0,x(1..16),lp;
     187   print(genericmat(4,4));    // the generic 4x4 matrix
     188   changevar("R1",A_Z("a",4),R);
     189   matrix A=genericmat(4,5,maxideal(1)^3);
     190   print(A);
     191   int n,m=4,3;
     192   ideal i = ideal(randommat(1,n*m,maxideal(1),9));
     193   print(genericmat(n,m,i));  // matrix of generic linear forms
     194   kill R1;
     195}
    164196///////////////////////////////////////////////////////////////////////////////
    165197
    166198proc is_complex (list c)
    167199USAGE:   is_complex(c); c = list of size-compatible modules or matrices
    168 RETURN:  1 if c[i]*c[i+1]=0 for all i, 0 if not. 
     200RETURN:  1 if c[i]*c[i+1]=0 for all i, 0 if not.
    169201NOTE:    Ideals are treated internally as 1-line matrices
    170202EXAMPLE: example is_complex; shows an example
    … …  
    186218}
    187219example
    188 { "EXAMPLE:";   echo = 2; 
    189    ring r=32003,(x,y,z),ds; 
    190    ideal i=x4+y5+z6,xyz,yx2+xz2+zy7; 
     220{ "EXAMPLE:";   echo = 2;
     221   ring r=32003,(x,y,z),ds;
     222   ideal i=x4+y5+z6,xyz,yx2+xz2+zy7;
    191223   list L=res(i,0);
    192224   is_complex(L);
    … …  
    202234{
    203235   int i,j; list L;
    204    int N=nrows(A)*nrows(B);
    205    matrix C[N][ncols(B)];
    206    for( i=1; i<=ncols(A); i++ )
    207    {
    208       for( j=1; j<=nrows(A); j++ )
    209       {
    210          C[(j-1)*nrows(B)+1..j*nrows(B),1..ncols(B)]=A[j,i]*B;
    211       }
    212       L[i]=C;
    213    }
    214    return(concat(L));
     236   int triv = nrows(B)*ncols(B);
     237   if( triv==1 )
     238   {
     239     return(B[1,1]*A);
     240   }
     241   else
     242   {
     243     int N = nrows(A)*nrows(B);
     244     matrix C[N][ncols(B)];
     245     for( i=1; i<=ncols(A); i=i+1 )
     246     {
     247       for( j=1; j<=nrows(A); j=j+1 )
     248       {
     249          C[(j-1)*nrows(B)+1..j*nrows(B),1..ncols(B)]=A[j,i]*B;
     250       }
     251       L[i]=C;
     252     }
     253     return(concat(L));
     254   }
    215255}
    216256example
    … …  
    227267proc skewmat (int n, list #)
    228268USAGE:   skewmat(n[,id]);  n integer, id ideal
    229 RETURN:  skew-symmetric nxn matrix, with entries from id 
     269RETURN:  skew-symmetric nxn matrix, with entries from id
    230270         (default: id=maxideal(1))
    231271NOTE:    if id has less than n*(n-1)/2 elements, the matrix is filled with 0's,
    … …  
    238278   id = id,B[1..n,1..n];
    239279   int i,j;
    240    for( i=0; i<=n-2; i++ )
    241    { 
    242       B[i+1,i+2..n]=id[j+1..j+n-i-1]; 
    243       j=j+n-i-1; 
     280   for( i=0; i<=n-2; i=i+1 )
     281   {
     282      B[i+1,i+2..n]=id[j+1..j+n-i-1];
     283      j=j+n-i-1;
    244284   }
    245285   matrix A=transpose(B);
    … …  
    263303proc submat (matrix A, intvec r, intvec c)
    264304USAGE:   submat(A,r,c);  A=matrix, r,c=intvec
    265 RETURN:  matrix, submatrix of A with rows specified by intvec r and columns 
     305RETURN:  matrix, submatrix of A with rows specified by intvec r and columns
    266306         specified by intvec c
    267307EXAMPLE: example submat; shows an example
    … …  
    293333   id = id,B[1..n,1..n];
    294334   int i,j;
    295    for( i=0; i<=n-1; i++ )
    296    { 
    297       B[i+1,i+1..n]=id[j+1..j+n-i]; 
    298       j=j+n-i; 
     335   for( i=0; i<=n-1; i=i+1 )
     336   {
     337      B[i+1,i+1..n]=id[j+1..j+n-i];
     338      j=j+n-i;
    299339   }
    300340   matrix A=transpose(B);
    301    for( i=1; i<=n; i++ ) {  A[i,i]=0; }
     341   for( i=1; i<=n; i=i+1 ) {  A[i,i]=0; }
    302342   B=A+B;
    303343   return(B);
    … …  
    306346{ "EXAMPLE:"; echo = 2;
    307347   ring R=0,x(1..10),lp;
    308    print(symmat(4));    // the generic symmetric matrix 
     348   print(symmat(4));    // the generic symmetric matrix
    309349   changevar("R1",A_Z("a",5),R);
    310350   matrix A=symmat(5,maxideal(1)^2);
    … …  
    324364   int i,j;
    325365   matrix C=B;
    326    for( i=2; i<=nrows(A); i++ ) { C=dsum(C,B); }
     366   for( i=2; i<=nrows(A); i=i+1 ) { C=dsum(C,B); }
    327367   matrix D[nrows(C)][ncols(A)*nrows(B)];
    328    for( j=1; j<=nrows(B); j++ )
    329    {
    330       for( i=1; i<=nrows(A); i++ )
     368   for( j=1; j<=nrows(B); j=j+1 )
     369   {
     370      for( i=1; i<=nrows(A); i=i+1 )
    331371      {
    332372         D[(i-1)*nrows(B)+j,(j-1)*ncols(A)+1..j*ncols(A)]=A[i,1..ncols(A)];
    … …  
    362402///////////////////////////////////////////////////////////////////////////////
    363403
    364 proc gauss_col (matrix m)
     404proc gauss_col (matrix A)
    365405USAGE:   gauss_col(A); A=matrix with constant coefficients
    366 RETURN:  matrix = col-reduced normal form of A
     406RETURN:  matrix = col-reduced lower-triagonal normal form of A
     407NOTE:    the procedure sets the global option-command: option(noredSB);
    367408EXAMPLE: example gauss_col; shows an example
    368409{
    369410   def R=basering;
    370    changeord("@R","ds,c",R);   
     411   changeord("@R","ds,c",R);
    371412   option(redSB); option(nointStrategy);
    372    matrix m = imap(R,m);
    373    m = matrix(std(m),nrows(m),ncols(m));
    374    setring R;   
    375    m=imap(@R,m);
     413   matrix A = imap(R,A);
     414   A = matrix(std(A),nrows(A),ncols(A));
     415   setring R;
     416   A=imap(@R,A);
    376417   option(noredSB);
    377418   kill @R;
    378    return(m);
    379 } 
    380 example
    381 { "EXAMPLE:"; echo = 2;
    382    ring S;
    383    matrix M[3][4] = 1,3,2,4,2,6,4,8,1,3,4,4;
    384    print(M);
    385    print(gauss_col(M));
     419   return(A);
     420}
     421example
     422{ "EXAMPLE:"; echo = 2;
     423   ring S=0,x,dp;
     424   matrix A[5][4] =  3, 1,1,-1,
     425                    13, 8,6,-7,
     426                    14,10,6,-7,
     427                     7, 4,3,-3,
     428                     2, 1,0, 3;
     429   print(gauss_col(A));
    386430}
    387431///////////////////////////////////////////////////////////////////////////////
    388432
    389 proc gauss_row (matrix m)
     433proc gauss_row (matrix A)
    390434USAGE:   gauss_row(A); A=matrix with constant coefficients
    391 RETURN:  matrix = row-reduced normal form of A
     435RETURN:  matrix = row-reduced upper-triangular normal form of A
     436NOTE:    may be used to solve a system of linear equations
     437         see proc 'linearsolve' from 'solve.lib' for a different method
     438         the procedure sets the global option-command: option(noredSB);
    392439EXAMPLE: example gauss_row; shows an example
    393440{
    394    m = gauss_col(transpose(m));
    395    return(transpose(m));
    396 } 
    397 example
    398 { "EXAMPLE:"; echo = 2;
    399    ring S;
    400    matrix M[3][4] = 1,3,2,4,2,6,4,8,1,3,4,4;
    401    print(M);
    402    print(gauss_row(M));
     441   A = gauss_col(transpose(A));
     442   return(transpose(A));
     443}
     444example
     445{ "EXAMPLE:"; echo = 2;
     446   ring S=0,x,dp;
     447   matrix A[4][5] =  3, 1,1,-1,2,
     448                    13, 8,6,-7,1,
     449                    14,10,6,-7,1,
     450                     7, 4,3,-3,3;
     451   print(gauss_row(A));
    403452}
    404453////////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.