[BACK]Return to array.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/array.c between version 1.27 and 1.32

version 1.27, 2003/01/06 01:16:37 version 1.32, 2003/09/17 08:14:26
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.26 2002/02/06 00:55:03 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.31 2003/07/01 08:12:37 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 84  void Pqsort();
Line 84  void Pqsort();
 void Pexponent_vector();  void Pexponent_vector();
 void Pmat_swap_row_destructive();  void Pmat_swap_row_destructive();
 void Pmat_swap_col_destructive();  void Pmat_swap_col_destructive();
   void Pvect();
   void Pmat();
   void Pmatc();
   
 struct ftab array_tab[] = {  struct ftab array_tab[] = {
         {"solve_by_lu_gfmmat",Psolve_by_lu_gfmmat,4},          {"solve_by_lu_gfmmat",Psolve_by_lu_gfmmat,4},
Line 92  struct ftab array_tab[] = {
Line 95  struct ftab array_tab[] = {
         {"generic_gauss_elim",Pgeneric_gauss_elim,1},          {"generic_gauss_elim",Pgeneric_gauss_elim,1},
         {"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},          {"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},
         {"newvect",Pnewvect,-2},          {"newvect",Pnewvect,-2},
           {"vect",Pvect,-99999999},
         {"vector",Pnewvect,-2},          {"vector",Pnewvect,-2},
         {"exponent_vector",Pexponent_vector,-99999999},          {"exponent_vector",Pexponent_vector,-99999999},
         {"newmat",Pnewmat,-3},          {"newmat",Pnewmat,-3},
         {"matrix",Pnewmat,-3},          {"matrix",Pnewmat,-3},
           {"mat",Pmat,-99999999},
           {"matr",Pmat,-99999999},
           {"matc",Pmatc,-99999999},
         {"newbytearray",Pnewbytearray,-2},          {"newbytearray",Pnewbytearray,-2},
         {"sepmat_destructive",Psepmat_destructive,2},          {"sepmat_destructive",Psepmat_destructive,2},
         {"sepvect",Psepvect,2},          {"sepvect",Psepvect,2},
Line 355  void Pnewvect(NODE arg,VECT *rp)
Line 362  void Pnewvect(NODE arg,VECT *rp)
         *rp = vect;          *rp = vect;
 }  }
   
   void Pvect(NODE arg,VECT *rp) {
           int len,i,r;
           VECT vect;
           pointer *vb;
           NODE tn;
   
           if ( !arg ) {
                   *rp =0;
                   return;
           }
   
           for (len = 0, tn = arg; tn; tn = NEXT(tn), len++);
           if ( len == 1 ) {
                   if ( ARG0(arg) != 0 ) {
                           switch ( OID(ARG0(arg)) ) {
                                   case O_VECT:
                                           *rp = ARG0(arg);
                                           return;
                                   case O_LIST:
                                           for ( len = 0, tn = ARG0(arg); tn; tn = NEXT(tn), len++ );
                                           MKVECT(vect,len-1);
                                           for ( i = 0, tn = BDY((LIST)ARG0(arg)), vb =BDY(vect);
                                                           tn; i++, tn = NEXT(tn) )
                                                   vb[i] = (pointer)BDY(tn);
                                           *rp=vect;
                                           return;
                           }
                   }
           }
           MKVECT(vect,len);
           for ( i = 0, tn = arg, vb = BDY(vect); tn; i++, tn = NEXT(tn) )
                   vb[i] = (pointer)BDY(tn);
           *rp = vect;
   }
   
 void Pexponent_vector(NODE arg,DP *rp)  void Pexponent_vector(NODE arg,DP *rp)
 {  {
         nodetod(arg,rp);          nodetod(arg,rp);
Line 437  void Pnewmat(NODE arg,MAT *rp)
Line 479  void Pnewmat(NODE arg,MAT *rp)
         *rp = m;          *rp = m;
 }  }
   
   void Pmat(NODE arg, MAT *rp)
   {
           int row,col;
           int i;
           MAT m;
           pointer **mb;
           pointer *ent;
           NODE tn, sn;
           VECT v;
   
           if ( !arg ) {
                   *rp =0;
                   return;
           }
   
           for (row = 0, tn = arg; tn; tn = NEXT(tn), row++);
           if ( row == 1 ) {
                   if ( OID(ARG0(arg)) == O_MAT ) {
                           *rp=ARG0(arg);
                           return;
                   } else if ( !(OID(ARG0(arg)) == O_LIST || OID(ARG0(arg)) == O_VECT)) {
                           error("mat : invalid argument");
                   }
           }
           if ( OID(ARG0(arg)) == O_VECT ) {
                   v = ARG0(arg);
                   col = v->len;
           } else if ( OID(ARG0(arg)) == O_LIST ) {
                   for (col = 0, tn = BDY((LIST)ARG0(arg)); tn ; tn = NEXT(tn), col++);
           } else {
                   error("mat : invalid argument");
           }
   
           MKMAT(m,row,col);
           for (row = 0, tn = arg, mb = BDY(m); tn; tn = NEXT(tn), row++) {
                   if ( BDY(tn) == 0 ) {
                           error("mat : invalid argument");
                   } else if ( OID(BDY(tn)) == O_VECT ) {
                           v = tn->body;
                           ent = BDY(v);
                           for (i = 0; i < v->len; i++ ) mb[row][i] = (Obj)ent[i];
                   } else if ( OID(BDY(tn)) == O_LIST ) {
                           for (col = 0, sn = BDY((LIST)BDY(tn)); sn; col++, sn = NEXT(sn) )
                                   mb[row][col] = (pointer)BDY(sn);
                   } else {
                           error("mat : invalid argument");
                   }
           }
           *rp = m;
   }
   
   void Pmatc(NODE arg, MAT *rp)
   {
           int row,col;
           int i;
           MAT m;
           pointer **mb;
           pointer *ent;
           NODE tn, sn;
           VECT v;
   
           if ( !arg ) {
                   *rp =0;
                   return;
           }
   
           for (col = 0, tn = arg; tn; tn = NEXT(tn), col++);
           if ( col == 1 ) {
                   if ( OID(ARG0(arg)) == O_MAT ) {
                           *rp=ARG0(arg);
                           return;
                   } else if ( !(OID(ARG0(arg)) == O_LIST || OID(ARG0(arg)) == O_VECT)) {
                           error("matc : invalid argument");
                   }
           }
           if ( OID(ARG0(arg)) == O_VECT ) {
                   v = ARG0(arg);
                   row = v->len;
           } else if ( OID(ARG0(arg)) == O_LIST ) {
                   for (row = 0, tn = BDY((LIST)ARG0(arg)); tn ; tn = NEXT(tn), row++);
           } else {
                   error("matc : invalid argument");
           }
   
           MKMAT(m,row,col);
           for (col = 0, tn = arg, mb = BDY(m); tn; tn = NEXT(tn), col++) {
                   if ( BDY(tn) == 0 ) {
                           error("matc : invalid argument");
                   } else if ( OID(BDY(tn)) == O_VECT ) {
                           v = tn->body;
                           ent = BDY(v);
                           for (i = 0; i < v->len; i++ ) mb[i][col] = (Obj)ent[i];
                   } else if ( OID(BDY(tn)) == O_LIST ) {
                           for (row = 0, sn = BDY((LIST)BDY(tn)); sn; row++, sn = NEXT(sn) )
                                   mb[row][col] = (pointer)BDY(sn);
                   } else {
                           error("matc : invalid argument");
                   }
           }
           *rp = m;
   }
   
 void Pvtol(NODE arg,LIST *rp)  void Pvtol(NODE arg,LIST *rp)
 {  {
         NODE n,n1;          NODE n,n1;
Line 809  int gauss_elim_mod(int **mat,int row,int col,int md)
Line 953  int gauss_elim_mod(int **mat,int row,int col,int md)
 }  }
   
 struct oEGT eg_mod,eg_elim,eg_elim1,eg_elim2,eg_chrem,eg_gschk,eg_intrat,eg_symb;  struct oEGT eg_mod,eg_elim,eg_elim1,eg_elim2,eg_chrem,eg_gschk,eg_intrat,eg_symb;
   struct oEGT eg_conv;
   
 int generic_gauss_elim(MAT mat,MAT *nm,Q *dn,int **rindp,int **cindp)  int generic_gauss_elim(MAT mat,MAT *nm,Q *dn,int **rindp,int **cindp)
 {  {
Line 1431  void red_by_vect(int m,unsigned int *p,unsigned int *r
Line 1576  void red_by_vect(int m,unsigned int *p,unsigned int *r
                 }                  }
 }  }
   
   void red_by_vect_sf(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)
   {
           *p++ = 0; r++; len--;
           for ( ; len; len--, r++, p++ )
                   if ( *r )
                           *p = _addsf(_mulsf(*r,hc),*p);
   }
   
 extern unsigned int **psca;  extern unsigned int **psca;
   
 void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,  void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,
Line 1515  int generic_gauss_elim_mod(int **mat0,int row,int col,
Line 1668  int generic_gauss_elim_mod(int **mat0,int row,int col,
                                 if ( t[k] >= (unsigned int)md )                                  if ( t[k] >= (unsigned int)md )
                                         t[k] %= md;                                          t[k] %= md;
                         l++;                          l++;
                   }
           return rank;
   }
   
   int generic_gauss_elim_sf(int **mat0,int row,int col,int md,int *colstat)
   {
           int i,j,k,l,inv,a,rank;
           unsigned int *t,*pivot,*pk;
           unsigned int **mat;
   
           mat = (unsigned int **)mat0;
           for ( rank = 0, j = 0; j < col; j++ ) {
                   for ( i = rank; i < row; i++ )
                           if ( mat[i][j] )
                                   break;
                   if ( i == row ) {
                           colstat[j] = 0;
                           continue;
                   } else
                           colstat[j] = 1;
                   if ( i != rank ) {
                           t = mat[i]; mat[i] = mat[rank]; mat[rank] = t;
                   }
                   pivot = mat[rank];
                   inv = _invsf(pivot[j]);
                   for ( k = j, pk = pivot+k; k < col; k++, pk++ )
                           if ( *pk )
                                   *pk = _mulsf(*pk,inv);
                   for ( i = rank+1; i < row; i++ ) {
                           t = mat[i];
                           if ( a = t[j] )
                                   red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);
                   }
                   rank++;
           }
           for ( j = col-1, l = rank-1; j >= 0; j-- )
                   if ( colstat[j] ) {
                           pivot = mat[l];
                           for ( i = 0; i < l; i++ ) {
                                   t = mat[i];
                                   if ( a = t[j] )
                                           red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);
                           }
                           l--;
                 }                  }
         return rank;          return rank;
 }  }
Legend:
Removed from v.1.27  
changed lines
  Added in v.1.32
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>