[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.14 and 1.43

version 1.14, 2001/09/04 05:14:03 version 1.43, 2004/12/18 16:50:10
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.13 2001/06/07 05:14:48 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.42 2004/12/13 23:04:16 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
 #include "parse.h"  #include "parse.h"
 #include "inline.h"  #include "inline.h"
   
   #define F4_INTRAT_PERIOD 8
   
 #if 0  #if 0
 #undef DMAR  #undef DMAR
 #define DMAR(a1,a2,a3,d,r) (r)=dmar(a1,a2,a3,d);  #define DMAR(a1,a2,a3,d,r) (r)=dmar(a1,a2,a3,d);
Line 59 
Line 61 
   
 extern int DP_Print; /* XXX */  extern int DP_Print; /* XXX */
   
 void inner_product_mat_int_mod(Q **,int **,int,int,int,Q *);  
 void solve_by_lu_mod(int **,int,int,int **,int);  
 void solve_by_lu_gfmmat(GFMMAT,unsigned int,unsigned int *,unsigned int *);  
 int lu_gfmmat(GFMMAT,unsigned int,int *);  
 void mat_to_gfmmat(MAT,unsigned int,GFMMAT *);  
   
 int generic_gauss_elim_mod(int **,int,int,int,int *);  
 int generic_gauss_elim(MAT ,MAT *,Q *,int **,int **);  
   
 int gauss_elim_mod(int **,int,int,int);  
 int gauss_elim_mod1(int **,int,int,int);  
 int gauss_elim_geninv_mod(unsigned int **,int,int,int);  
 int gauss_elim_geninv_mod_swap(unsigned int **,int,int,unsigned int,unsigned int ***,int **);  
 void Pnewvect(), Pnewmat(), Psepvect(), Psize(), Pdet(), Pleqm(), Pleqm1(), Pgeninvm();  void Pnewvect(), Pnewmat(), Psepvect(), Psize(), Pdet(), Pleqm(), Pleqm1(), Pgeninvm();
   void Pinvmat();
 void Pnewbytearray();  void Pnewbytearray();
   
   void Pgeneric_gauss_elim();
 void Pgeneric_gauss_elim_mod();  void Pgeneric_gauss_elim_mod();
   
 void Pmat_to_gfmmat(),Plu_gfmmat(),Psolve_by_lu_gfmmat();  void Pmat_to_gfmmat(),Plu_gfmmat(),Psolve_by_lu_gfmmat();
 void Pgeninvm_swap(), Premainder(), Psremainder(), Pvtol();  void Pgeninvm_swap(), Premainder(), Psremainder(), Pvtol(), Pltov();
   void Pgeninv_sf_swap();
 void sepvect();  void sepvect();
 void Pmulmat_gf2n();  void Pmulmat_gf2n();
 void Pbconvmat_gf2n();  void Pbconvmat_gf2n();
Line 91  void Pirredpoly_up2();
Line 84  void Pirredpoly_up2();
 void Pnbpoly_up2();  void Pnbpoly_up2();
 void Pqsort();  void Pqsort();
 void Pexponent_vector();  void Pexponent_vector();
   void Pmat_swap_row_destructive();
   void Pmat_swap_col_destructive();
   void Pvect();
   void Pmat();
   void Pmatc();
   void Pnd_det();
   
 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},
         {"lu_gfmmat",Plu_gfmmat,2},          {"lu_gfmmat",Plu_gfmmat,2},
         {"mat_to_gfmmat",Pmat_to_gfmmat,2},          {"mat_to_gfmmat",Pmat_to_gfmmat,2},
           {"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},
         {"qsort",Pqsort,-2},          {"qsort",Pqsort,-2},
         {"vtol",Pvtol,1},          {"vtol",Pvtol,1},
           {"ltov",Pltov,1},
         {"size",Psize,1},          {"size",Psize,1},
         {"det",Pdet,-2},          {"det",Pdet,-2},
           {"nd_det",Pnd_det,-2},
           {"invmat",Pinvmat,-2},
         {"leqm",Pleqm,2},          {"leqm",Pleqm,2},
         {"leqm1",Pleqm1,2},          {"leqm1",Pleqm1,2},
         {"geninvm",Pgeninvm,2},          {"geninvm",Pgeninvm,2},
         {"geninvm_swap",Pgeninvm_swap,2},          {"geninvm_swap",Pgeninvm_swap,2},
           {"geninv_sf_swap",Pgeninv_sf_swap,1},
         {"remainder",Premainder,2},          {"remainder",Premainder,2},
         {"sremainder",Psremainder,2},          {"sremainder",Psremainder,2},
         {"mulmat_gf2n",Pmulmat_gf2n,1},          {"mulmat_gf2n",Pmulmat_gf2n,1},
Line 123  struct ftab array_tab[] = {
Line 131  struct ftab array_tab[] = {
         {"x962_irredpoly_up2",Px962_irredpoly_up2,2},          {"x962_irredpoly_up2",Px962_irredpoly_up2,2},
         {"irredpoly_up2",Pirredpoly_up2,2},          {"irredpoly_up2",Pirredpoly_up2,2},
         {"nbpoly_up2",Pnbpoly_up2,2},          {"nbpoly_up2",Pnbpoly_up2,2},
           {"mat_swap_row_destructive",Pmat_swap_row_destructive,3},
           {"mat_swap_col_destructive",Pmat_swap_col_destructive,3},
         {0,0,0},          {0,0,0},
 };  };
   
 int comp_obj(a,b)  int comp_obj(Obj *a,Obj *b)
 Obj *a,*b;  
 {  {
         return arf_comp(CO,*a,*b);          return arf_comp(CO,*a,*b);
 }  }
Line 135  Obj *a,*b;
Line 144  Obj *a,*b;
 static FUNC generic_comp_obj_func;  static FUNC generic_comp_obj_func;
 static NODE generic_comp_obj_arg;  static NODE generic_comp_obj_arg;
   
 int generic_comp_obj(a,b)  int generic_comp_obj(Obj *a,Obj *b)
 Obj *a,*b;  
 {  {
         Q r;          Q r;
   
Line 150  Obj *a,*b;
Line 158  Obj *a,*b;
 }  }
   
   
 void Pqsort(arg,rp)  void Pqsort(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         VECT vect;          VECT vect;
         char buf[BUFSIZ];          NODE n,n1;
         char *fname;  
         NODE n;  
         P p;          P p;
         V v;          V v;
           FUNC func;
           int len,i;
           pointer *a;
           Obj t;
   
         asir_assert(ARG0(arg),O_VECT,"qsort");          t = ARG0(arg);
         vect = (VECT)ARG0(arg);      if (OID(t) == O_LIST) {
           n = (NODE)BDY((LIST)t);
           len = length(n);
           MKVECT(vect,len);
           for ( i = 0; i < len; i++, n = NEXT(n) ) {
               BDY(vect)[i] = BDY(n);
           }
   
       }else if (OID(t) != O_VECT) {
           error("qsort : invalid argument");
       }else {
           vect = (VECT)t;
       }
         if ( argc(arg) == 1 )          if ( argc(arg) == 1 )
                 qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))comp_obj);                  qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))comp_obj);
         else {          else {
Line 170  VECT *rp;
Line 190  VECT *rp;
                 if ( !p || OID(p)!=2 )                  if ( !p || OID(p)!=2 )
                         error("qsort : invalid argument");                          error("qsort : invalid argument");
                 v = VR(p);                  v = VR(p);
                 if ( (int)v->attr != V_SR )                  gen_searchf(NAME(v),&func);
                         error("qsort : no such function");                  if ( !func ) {
                 generic_comp_obj_func = (FUNC)v->priv;                          if ( (int)v->attr != V_SR )
                                   error("qsort : no such function");
                           func = (FUNC)v->priv;
                   }
                   generic_comp_obj_func = func;
                 MKNODE(n,0,0); MKNODE(generic_comp_obj_arg,0,n);                  MKNODE(n,0,0); MKNODE(generic_comp_obj_arg,0,n);
                 qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))generic_comp_obj);                  qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))generic_comp_obj);
         }          }
         *rp = vect;      if (OID(t) == O_LIST) {
           a = BDY(vect);
           for ( i = len - 1, n = 0; i >= 0; i-- ) {
               MKNODE(n1,a[i],n); n = n1;
           }
           MKLIST((LIST)*rp,n);
       }else {
           *rp = vect;
       }
 }  }
   
 void PNBmul_gf2n(arg,rp)  void PNBmul_gf2n(NODE arg,GF2N *rp)
 NODE arg;  
 GF2N *rp;  
 {  {
         GF2N a,b;          GF2N a,b;
         GF2MAT mat;          GF2MAT mat;
Line 218  GF2N *rp;
Line 248  GF2N *rp;
         }          }
 }  }
   
 void Pmul_vect_mat_gf2n(arg,rp)  void Pmul_vect_mat_gf2n(NODE arg,GF2N *rp)
 NODE arg;  
 GF2N *rp;  
 {  {
         GF2N a;          GF2N a;
         GF2MAT mat;          GF2MAT mat;
Line 251  GF2N *rp;
Line 279  GF2N *rp;
         }          }
 }  }
   
 void Pbconvmat_gf2n(arg,rp)  void Pbconvmat_gf2n(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
         P p0,p1;          P p0,p1;
         int to;          int to;
Line 273  LIST *rp;
Line 299  LIST *rp;
         MKLIST(*rp,n0);          MKLIST(*rp,n0);
 }  }
   
 void Pmulmat_gf2n(arg,rp)  void Pmulmat_gf2n(NODE arg,GF2MAT *rp)
 NODE arg;  
 GF2MAT *rp;  
 {  {
         GF2MAT m;          GF2MAT m;
   
Line 284  GF2MAT *rp;
Line 308  GF2MAT *rp;
         *rp = m;          *rp = m;
 }  }
   
 void Psepmat_destructive(arg,rp)  void Psepmat_destructive(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
         MAT mat,mat1;          MAT mat,mat1;
         int i,j,row,col;          int i,j,row,col;
Line 317  LIST *rp;
Line 339  LIST *rp;
         MKLIST(*rp,n0);          MKLIST(*rp,n0);
 }  }
   
 void Psepvect(arg,rp)  void Psepvect(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         sepvect((VECT)ARG0(arg),QTOS((Q)ARG1(arg)),rp);          sepvect((VECT)ARG0(arg),QTOS((Q)ARG1(arg)),rp);
 }  }
   
 void sepvect(v,d,rp)  void sepvect(VECT v,int d,VECT *rp)
 VECT v;  
 int d;  
 VECT *rp;  
 {  {
         int i,j,k,n,q,q1,r;          int i,j,k,n,q,q1,r;
         pointer *pv,*pw,*pu;          pointer *pv,*pw,*pu;
Line 351  VECT *rp;
Line 368  VECT *rp;
         }          }
 }  }
   
 void Pnewvect(arg,rp)  void Pnewvect(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         int len,i,r;          int len,i,r;
         VECT vect;          VECT vect;
Line 380  VECT *rp;
Line 395  VECT *rp;
         *rp = vect;          *rp = vect;
 }  }
   
 void Pexponent_vector(arg,rp)  void Pvect(NODE arg,VECT *rp) {
 NODE arg;          int len,i,r;
 DP *rp;          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)
 {  {
         nodetod(arg,rp);          nodetod(arg,rp);
 }  }
   
 void Pnewbytearray(arg,rp)  void Pnewbytearray(NODE arg,BYTEARRAY *rp)
 NODE arg;  
 BYTEARRAY *rp;  
 {  {
         int len,i,r;          int len,i,r;
         BYTEARRAY array;          BYTEARRAY array;
Line 431  BYTEARRAY *rp;
Line 477  BYTEARRAY *rp;
         *rp = array;          *rp = array;
 }  }
   
 void Pnewmat(arg,rp)  void Pnewmat(NODE arg,MAT *rp)
 NODE arg;  
 MAT *rp;  
 {  {
         int row,col;          int row,col;
         int i,j,r,c;          int i,j,r,c;
Line 468  MAT *rp;
Line 512  MAT *rp;
         *rp = m;          *rp = m;
 }  }
   
 void Pvtol(arg,rp)  void Pmat(NODE arg, MAT *rp)
 NODE arg;  
 LIST *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)
   {
         NODE n,n1;          NODE n,n1;
         VECT v;          VECT v;
         pointer *a;          pointer *a;
Line 485  LIST *rp;
Line 629  LIST *rp;
         MKLIST(*rp,n);          MKLIST(*rp,n);
 }  }
   
 void Premainder(arg,rp)  void Pltov(NODE arg,VECT *rp)
 NODE arg;  
 Obj *rp;  
 {  {
           NODE n;
           VECT v;
           int len,i;
   
           asir_assert(ARG0(arg),O_LIST,"ltov");
           n = (NODE)BDY((LIST)ARG0(arg));
           len = length(n);
           MKVECT(v,len);
           for ( i = 0; i < len; i++, n = NEXT(n) )
                   BDY(v)[i] = BDY(n);
           *rp = v;
   }
   
   void Premainder(NODE arg,Obj *rp)
   {
         Obj a;          Obj a;
         VECT v,w;          VECT v,w;
         MAT m,l;          MAT m,l;
Line 535  Obj *rp;
Line 692  Obj *rp;
         }          }
 }  }
   
 void Psremainder(arg,rp)  void Psremainder(NODE arg,Obj *rp)
 NODE arg;  
 Obj *rp;  
 {  {
         Obj a;          Obj a;
         VECT v,w;          VECT v,w;
Line 586  Obj *rp;
Line 741  Obj *rp;
         }          }
 }  }
   
 void Psize(arg,rp)  void Psize(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
   
         int n,m;          int n,m;
Line 607  LIST *rp;
Line 760  LIST *rp;
                                 n = ((MAT)ARG0(arg))->row; m = ((MAT)ARG0(arg))->col;                                  n = ((MAT)ARG0(arg))->row; m = ((MAT)ARG0(arg))->col;
                                 STOQ(m,q); MKNODE(s,q,0); STOQ(n,q); MKNODE(t,q,s);                                  STOQ(m,q); MKNODE(s,q,0); STOQ(n,q); MKNODE(t,q,s);
                                 break;                                  break;
                           case O_IMAT:
                                   n = ((IMAT)ARG0(arg))->row; m = ((IMAT)ARG0(arg))->col;
                                   STOQ(m,q); MKNODE(s,q,0); STOQ(n,q); MKNODE(t,q,s);
                                   break;
                         default:                          default:
                                 error("size : invalid argument"); break;                                  error("size : invalid argument"); break;
                 }                  }
Line 614  LIST *rp;
Line 771  LIST *rp;
         MKLIST(*rp,t);          MKLIST(*rp,t);
 }  }
   
 void Pdet(arg,rp)  void Pdet(NODE arg,P *rp)
 NODE arg;  
 P *rp;  
 {  {
         MAT m;          MAT m;
         int n,i,j,mod;          int n,i,j,mod;
Line 640  P *rp;
Line 795  P *rp;
         }          }
 }  }
   
   void Pinvmat(NODE arg,LIST *rp)
   {
           MAT m,r;
           int n,i,j,mod;
           P dn;
           P **mat,**imat,**w;
           NODE nd;
   
           m = (MAT)ARG0(arg);
           asir_assert(m,O_MAT,"invmat");
           if ( m->row != m->col )
                   error("invmat : non-square matrix");
           else if ( argc(arg) == 1 ) {
                   n = m->row;
                   invmatp(CO,(P **)BDY(m),n,&imat,&dn);
                   NEWMAT(r); r->row = n; r->col = n; r->body = (pointer **)imat;
                   nd = mknode(2,r,dn);
                   MKLIST(*rp,nd);
           } else {
                   n = m->row; mod = QTOS((Q)ARG1(arg)); mat = (P **)BDY(m);
                   w = (P **)almat_pointer(n,n);
                   for ( i = 0; i < n; i++ )
                           for ( j = 0; j < n; j++ )
                                   ptomp(mod,mat[i][j],&w[i][j]);
   #if 0
                   detmp(CO,mod,w,n,&d);
                   mptop(d,rp);
   #else
                   error("not implemented yet");
   #endif
           }
   }
   
 /*  /*
         input : a row x col matrix A          input : a row x col matrix A
                 A[I] <-> A[I][0]*x_0+A[I][1]*x_1+...                  A[I] <-> A[I][0]*x_0+A[I][1]*x_1+...
Line 651  P *rp;
Line 839  P *rp;
                 B[I] <-> x_{R[I]}+B[I][0]x_{C[0]}+B[I][1]x_{C[1]}+...                  B[I] <-> x_{R[I]}+B[I][0]x_{C[0]}+B[I][1]x_{C[1]}+...
 */  */
   
 void Pgeneric_gauss_elim_mod(arg,rp)  void Pgeneric_gauss_elim(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
         NODE n0;          NODE n0;
           MAT m,nm;
           int *ri,*ci;
           VECT rind,cind;
           Q dn,q;
           int i,j,k,l,row,col,t,rank;
   
           asir_assert(ARG0(arg),O_MAT,"generic_gauss_elim");
           m = (MAT)ARG0(arg);
           row = m->row; col = m->col;
           rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);
           t = col-rank;
           MKVECT(rind,rank);
           MKVECT(cind,t);
           for ( i = 0; i < rank; i++ ) {
                   STOQ(ri[i],q);
                   BDY(rind)[i] = (pointer)q;
           }
           for ( i = 0; i < t; i++ ) {
                   STOQ(ci[i],q);
                   BDY(cind)[i] = (pointer)q;
           }
           n0 = mknode(4,nm,dn,rind,cind);
           MKLIST(*rp,n0);
   }
   
   /*
           input : a row x col matrix A
                   A[I] <-> A[I][0]*x_0+A[I][1]*x_1+...
   
           output : [B,R,C]
                   B : a rank(A) x col-rank(A) matrix
                   R : a vector of length rank(A)
                   C : a vector of length col-rank(A)
                   B[I] <-> x_{R[I]}+B[I][0]x_{C[0]}+B[I][1]x_{C[1]}+...
   */
   
   void Pgeneric_gauss_elim_mod(NODE arg,LIST *rp)
   {
           NODE n0;
         MAT m,mat;          MAT m,mat;
         VECT rind,cind;          VECT rind,cind;
         Q **tmat;          Q **tmat;
Line 663  LIST *rp;
Line 888  LIST *rp;
         Q *rib,*cib;          Q *rib,*cib;
         int *colstat;          int *colstat;
         Q q;          Q q;
         int md,i,j,k,l,row,col,t,n,rank;          int md,i,j,k,l,row,col,t,rank;
   
         asir_assert(ARG0(arg),O_MAT,"generic_gauss_elim_mod");          asir_assert(ARG0(arg),O_MAT,"generic_gauss_elim_mod");
         asir_assert(ARG1(arg),O_N,"generic_gauss_elim_mod");          asir_assert(ARG1(arg),O_N,"generic_gauss_elim_mod");
Line 703  LIST *rp;
Line 928  LIST *rp;
         MKLIST(*rp,n0);          MKLIST(*rp,n0);
 }  }
   
 void Pleqm(arg,rp)  void Pleqm(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         MAT m;          MAT m;
         VECT vect;          VECT vect;
Line 744  VECT *rp;
Line 967  VECT *rp;
         }          }
 }  }
   
 int gauss_elim_mod(mat,row,col,md)  int gauss_elim_mod(int **mat,int row,int col,int md)
 int **mat;  
 int row,col,md;  
 {  {
         int i,j,k,inv,a,n;          int i,j,k,inv,a,n;
         int *t,*pivot;          int *t,*pivot;
Line 784  int row,col,md;
Line 1005  int row,col,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,nm,dn,rindp,cindp)  int generic_gauss_elim(MAT mat,MAT *nm,Q *dn,int **rindp,int **cindp)
 MAT mat;  
 MAT *nm;  
 Q *dn;  
 int **rindp,**cindp;  
 {  {
         int **wmat;          int **wmat;
         Q **bmat;          Q **bmat;
Line 906  RESET:
Line 1124  RESET:
                         add_eg(&eg_chrem_split,&tmp0,&tmp1);                          add_eg(&eg_chrem_split,&tmp0,&tmp1);
   
                         get_eg(&tmp0);                          get_eg(&tmp0);
                         if ( ind % 16 )                          if ( ind % F4_INTRAT_PERIOD )
                                 ret = 0;                                  ret = 0;
                         else                          else
                                 ret = intmtoratm(crmat,m1,*nm,dn);                                  ret = intmtoratm(crmat,m1,*nm,dn);
Line 941  RESET:
Line 1159  RESET:
         }          }
 }  }
   
 int generic_gauss_elim_hensel(mat,nmmat,dn,rindp,cindp)  int generic_gauss_elim_hensel(MAT mat,MAT *nmmat,Q *dn,int **rindp,int **cindp)
 MAT mat;  
 MAT *nmmat;  
 Q *dn;  
 int **rindp,**cindp;  
 {  {
         MAT bmat,xmat;          MAT bmat,xmat;
         Q **a0,**a,**b,**x,**nm;          Q **a0,**a,**b,**x,**nm;
Line 961  int **rindp,**cindp;
Line 1175  int **rindp,**cindp;
         int *cinfo,*rinfo;          int *cinfo,*rinfo;
         int *rind,*cind;          int *rind,*cind;
         int count;          int count;
         struct oEGT eg_mul,eg_inv,tmp0,tmp1;          int ret;
           struct oEGT eg_mul,eg_inv,eg_intrat,eg_check,tmp0,tmp1;
           int period;
   
         a0 = (Q **)mat->body;          a0 = (Q **)mat->body;
         row = mat->row; col = mat->col;          row = mat->row; col = mat->col;
Line 979  int **rindp,**cindp;
Line 1195  int **rindp,**cindp;
                                 } else                                  } else
                                         wi[j] = 0;                                          wi[j] = 0;
   
                 rank = find_lhs_and_lu_mod(w,row,col,md,&rinfo,&cinfo);                  rank = find_lhs_and_lu_mod((unsigned int **)w,row,col,md,&rinfo,&cinfo);
                 a = (Q **)almat_pointer(rank,rank); /* lhs mat */                  a = (Q **)almat_pointer(rank,rank); /* lhs mat */
                 MKMAT(bmat,rank,col-rank); b = (Q **)bmat->body; /* lhs mat */                  MKMAT(bmat,rank,col-rank); b = (Q **)bmat->body; /* lhs mat */
                 for ( j = li = ri = 0; j < col; j++ )                  for ( j = li = ri = 0; j < col; j++ )
Line 1009  int **rindp,**cindp;
Line 1225  int **rindp,**cindp;
                         *cindp = cind = (int *)MALLOC_ATOMIC((ri)*sizeof(int));                          *cindp = cind = (int *)MALLOC_ATOMIC((ri)*sizeof(int));
   
                         init_eg(&eg_mul); init_eg(&eg_inv);                          init_eg(&eg_mul); init_eg(&eg_inv);
                           init_eg(&eg_check); init_eg(&eg_intrat);
                           period = F4_INTRAT_PERIOD;
                         for ( q = ONE, count = 0; ; count++ ) {                          for ( q = ONE, count = 0; ; count++ ) {
                                 fprintf(stderr,".");                                  if ( DP_Print > 3 )
                                           fprintf(stderr,"o");
                                 /* wc = -b mod md */                                  /* wc = -b mod md */
                                 for ( i = 0; i < rank; i++ )                                  for ( i = 0; i < rank; i++ )
                                         for ( j = 0, bi = b[i], wi = wc[i]; j < ri; j++ )                                          for ( j = 0, bi = b[i], wi = wc[i]; j < ri; j++ )
Line 1049  int **rindp,**cindp;
Line 1268  int **rindp,**cindp;
                                 add_eg(&eg_mul,&tmp0,&tmp1);                                  add_eg(&eg_mul,&tmp0,&tmp1);
                                 /* q = q*md */                                  /* q = q*md */
                                 mulq(q,mdq,&u); q = u;                                  mulq(q,mdq,&u); q = u;
                                 if ( !(count % 16) && intmtoratm_q(xmat,NM(q),*nmmat,dn) ) {                                  if ( !(count % period) ) {
                                         for ( j = k = l = 0; j < col; j++ )                                          get_eg(&tmp0);
                                                 if ( cinfo[j] )                                          ret = intmtoratm_q(xmat,NM(q),*nmmat,dn);
                                                         rind[k++] = j;                                          get_eg(&tmp1); add_eg(&eg_intrat,&tmp0,&tmp1);
                                                 else                                          if ( ret ) {
                                                         cind[l++] = j;                                                  for ( j = k = l = 0; j < col; j++ )
                                         if ( gensolve_check(mat,*nmmat,*dn,rind,cind) ) {                                                          if ( cinfo[j] )
                                                 fprintf(stderr,"\n");                                                                  rind[k++] = j;
                                                 print_eg("INV",&eg_inv);                                                          else
                                                 print_eg("MUL",&eg_mul);                                                                  cind[l++] = j;
                                                 fflush(asir_out);                                                  get_eg(&tmp0);
                                                 return rank;                                                  ret = gensolve_check(mat,*nmmat,*dn,rind,cind);
                                         }                                                  get_eg(&tmp1); add_eg(&eg_check,&tmp0,&tmp1);
                                                   if ( ret ) {
                                                           if ( DP_Print > 3 ) {
                                                                   fprintf(stderr,"\n");
                                                                   print_eg("INV",&eg_inv);
                                                                   print_eg("MUL",&eg_mul);
                                                                   print_eg("INTRAT",&eg_intrat);
                                                                   print_eg("CHECK",&eg_check);
                                                                   fflush(asir_out);
                                                           }
                                                           return rank;
                                                   }
                                           } else
                                                   period *=2;
                                 }                                  }
                         }                          }
         }          }
Line 1069  int **rindp,**cindp;
Line 1301  int **rindp,**cindp;
   
 int f4_nocheck;  int f4_nocheck;
   
 int gensolve_check(mat,nm,dn,rind,cind)  int gensolve_check(MAT mat,MAT nm,Q dn,int *rind,int *cind)
 MAT mat,nm;  
 Q dn;  
 int *rind,*cind;  
 {  {
         int row,col,rank,clen,i,j,k,l;          int row,col,rank,clen,i,j,k,l;
         Q s,t,u;          Q s,t;
         Q *w;          Q *w;
         Q *mati,*nmk;          Q *mati,*nmk;
   
Line 1120  int *rind,*cind;
Line 1349  int *rind,*cind;
   
 /* assuming 0 < c < m */  /* assuming 0 < c < m */
   
 int inttorat(c,m,b,sgnp,nmp,dnp)  int inttorat(N c,N m,N b,int *sgnp,N *nmp,N *dnp)
 N c,m,b;  
 int *sgnp;  
 N *nmp,*dnp;  
 {  {
         Q qq,t,u1,v1,r1,nm;          Q qq,t,u1,v1,r1;
         N q,r,u2,v2,r2;          N q,u2,v2,r2;
   
         u1 = 0; v1 = ONE; u2 = m; v2 = c;          u1 = 0; v1 = ONE; u2 = m; v2 = c;
         while ( cmpn(v2,b) >= 0 ) {          while ( cmpn(v2,b) >= 0 ) {
Line 1145  N *nmp,*dnp;
Line 1371  N *nmp,*dnp;
   
 /* mat->body = N ** */  /* mat->body = N ** */
   
 int intmtoratm(mat,md,nm,dn)  int intmtoratm(MAT mat,N md,MAT nm,Q *dn)
 MAT mat;  
 N md;  
 MAT nm;  
 Q *dn;  
 {  {
         N t,s,b;          N t,s,b;
         Q bound,dn0,dn1,nm1,q,tq;          Q dn0,dn1,nm1,q;
         int i,j,k,l,row,col;          int i,j,k,l,row,col;
         Q **rmat;          Q **rmat;
         N **tmat;          N **tmat;
Line 1202  Q *dn;
Line 1424  Q *dn;
   
 /* mat->body = Q ** */  /* mat->body = Q ** */
   
 int intmtoratm_q(mat,md,nm,dn)  int intmtoratm_q(MAT mat,N md,MAT nm,Q *dn)
 MAT mat;  
 N md;  
 MAT nm;  
 Q *dn;  
 {  {
         N t,s,b;          N t,s,b;
         Q bound,dn0,dn1,nm1,q,tq;          Q dn0,dn1,nm1,q;
         int i,j,k,l,row,col;          int i,j,k,l,row,col;
         Q **rmat;          Q **rmat;
         Q **tmat;          Q **tmat;
Line 1261  Q *dn;
Line 1479  Q *dn;
   
 #define ONE_STEP1  if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;  #define ONE_STEP1  if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;
   
 void reduce_reducers_mod(mat,row,col,md)  void reduce_reducers_mod(int **mat,int row,int col,int md)
 int **mat;  
 int row,col;  
 int md;  
 {  {
         int i,j,k,l,hc,zzz;          int i,j,k,l,hc,zzz;
         int *t,*s,*tj,*ind;          int *t,*s,*tj,*ind;
Line 1303  int md;
Line 1518  int md;
                                         ONE_STEP1 ONE_STEP1 ONE_STEP1 ONE_STEP1                                          ONE_STEP1 ONE_STEP1 ONE_STEP1 ONE_STEP1
                                         ONE_STEP1 ONE_STEP1 ONE_STEP1 ONE_STEP1                                          ONE_STEP1 ONE_STEP1 ONE_STEP1 ONE_STEP1
                                 }                                  }
                                 for ( ; k >= 0; k-- ) {                                  for ( ; k > 0; k-- ) {
                                         if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;                                          if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;
                                 }                                  }
                         }                          }
Line 1319  int md;
Line 1534  int md;
         2. reduce spolys by the reduced reducers          2. reduce spolys by the reduced reducers
 */  */
   
 void pre_reduce_mod(mat,row,col,nred,md)  void pre_reduce_mod(int **mat,int row,int col,int nred,int md)
 int **mat;  
 int row,col,nred;  
 int md;  
 {  {
         int i,j,k,l,hc,inv;          int i,j,k,l,hc,inv;
         int *t,*s,*tk,*ind;          int *t,*s,*tk,*ind;
Line 1372  int md;
Line 1584  int md;
         mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order          mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order
 */  */
   
 void reduce_sp_by_red_mod(sp,redmat,ind,nred,col,md)  void reduce_sp_by_red_mod(int *sp,int **redmat,int *ind,int nred,int col,int md)
 int *sp,**redmat;  
 int *ind;  
 int nred,col;  
 int md;  
 {  {
         int i,j,k,hc,zzz;          int i,j,k,hc,zzz;
         int *t,*s,*tj;          int *s,*tj;
   
         /* reduce the spolys by redmat */          /* reduce the spolys by redmat */
         for ( i = nred-1; i >= 0; i-- ) {          for ( i = nred-1; i >= 0; i-- ) {
Line 1390  int md;
Line 1598  int md;
                         hc = md-hc;                          hc = md-hc;
                         s = redmat[i]+j;                          s = redmat[i]+j;
                         tj = sp+j;                          tj = sp+j;
                         for ( k = col-j; k >= 0; k-- ) {                          for ( k = col-j; k > 0; k-- ) {
                                 if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;                                  if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;
                         }                          }
                 }                  }
         }          }
 }  }
   
   /*
           mat[i] : compressed reducers (i=0,...,nred-1)
           mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order
   */
   
   void red_by_compress(int m,unsigned int *p,unsigned int *r,
           unsigned int *ri,unsigned int hc,int len)
   {
           unsigned int up,lo;
           unsigned int dmy;
           unsigned int *pj;
   
           p[*ri] = 0; r++; ri++;
           for ( len--; len; len--, r++, ri++ ) {
                   pj = p+ *ri;
                   DMA(*r,hc,*pj,up,lo);
                   if ( up ) {
                           DSAB(m,up,lo,dmy,*pj);
                   } else
                           *pj = lo;
           }
   }
   
   /* p -= hc*r */
   
   void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)
   {
           register unsigned int up,lo;
           unsigned int dmy;
   
           *p++ = 0; r++; len--;
           for ( ; len; len--, r++, p++ )
                   if ( *r ) {
                           DMA(*r,hc,*p,up,lo);
                           if ( up ) {
                                   DSAB(m,up,lo,dmy,*p);
                           } else
                                   *p = lo;
                   }
   }
   
   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;
   
   void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,
           int nred,int col,int md)
   {
           int i,len;
           CDP ri;
           unsigned int hc;
           unsigned int *usp;
   
           usp = (unsigned int *)sp;
           /* reduce the spolys by redmat */
           for ( i = nred-1; i >= 0; i-- ) {
                   /* reduce sp by redmat[i] */
                   usp[ind[i]] %= md;
                   if ( hc = usp[ind[i]] ) {
                           /* sp = sp-hc*redmat[i] */
                           hc = md-hc;
                           ri = redmat[i];
                           len = ri->len;
                           red_by_compress(md,usp,psca[ri->psindex],ri->body,hc,len);
                   }
           }
           for ( i = 0; i < col; i++ )
                   if ( usp[i] >= (unsigned int)md )
                           usp[i] %= md;
   }
   
 #define ONE_STEP2  if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;  #define ONE_STEP2  if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;
   
 int generic_gauss_elim_mod(mat,row,col,md,colstat)  int generic_gauss_elim_mod(int **mat0,int row,int col,int md,int *colstat)
 int **mat;  
 int row,col,md;  
 int *colstat;  
 {  {
         int i,j,k,l,inv,a,rank,zzz;          int i,j,k,l,inv,a,rank;
         int *t,*pivot,*pk,*tk;          unsigned int *t,*pivot,*pk;
           unsigned int **mat;
   
           mat = (unsigned int **)mat0;
         for ( rank = 0, j = 0; j < col; j++ ) {          for ( rank = 0, j = 0; j < col; j++ ) {
                 for ( i = rank; i < row && !mat[i][j]; i++ );                  for ( i = rank; i < row; i++ )
                           mat[i][j] %= md;
                   for ( i = rank; i < row; i++ )
                           if ( mat[i][j] )
                                   break;
                 if ( i == row ) {                  if ( i == row ) {
                         colstat[j] = 0;                          colstat[j] = 0;
                         continue;                          continue;
Line 1421  int *colstat;
Line 1709  int *colstat;
                 inv = invm(pivot[j],md);                  inv = invm(pivot[j],md);
                 for ( k = j, pk = pivot+k; k < col; k++, pk++ )                  for ( k = j, pk = pivot+k; k < col; k++, pk++ )
                         if ( *pk ) {                          if ( *pk ) {
                                   if ( *pk >= (unsigned int)md )
                                           *pk %= md;
                                 DMAR(*pk,inv,0,md,*pk)                                  DMAR(*pk,inv,0,md,*pk)
                         }                          }
                 for ( i = rank+1; i < row; i++ ) {                  for ( i = rank+1; i < row; i++ ) {
                         t = mat[i];                          t = mat[i];
                         if ( a = t[j] ) {                          if ( a = t[j] )
                                 a = md - a; pk = pivot+j; tk = t+j;                                  red_by_vect(md,t+j,pivot+j,md-a,col-j);
                                 k = col-j;                  }
                                 for ( ; k >= 64; k -= 64 ) {                  rank++;
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2          }
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2          for ( j = col-1, l = rank-1; j >= 0; j-- )
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                  if ( colstat[j] ) {
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                          pivot = mat[l];
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                          for ( i = 0; i < l; i++ ) {
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                                  t = mat[i];
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                                  t[j] %= md;
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                                  if ( a = t[j] )
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2                                          red_by_vect(md,t+j,pivot+j,md-a,col-j);
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                 }  
                                 for ( ; k >= 0; k -- ) {  
                                         if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;  
                                 }  
                         }                          }
                           l--;
                 }                  }
           for ( j = 0, l = 0; l < rank; j++ )
                   if ( colstat[j] ) {
                           t = mat[l];
                           for ( k = j; k < col; k++ )
                                   if ( t[k] >= (unsigned int)md )
                                           t[k] %= md;
                           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++;                  rank++;
         }          }
         for ( j = col-1, l = rank-1; j >= 0; j-- )          for ( j = col-1, l = rank-1; j >= 0; j-- )
Line 1458  int *colstat;
Line 1778  int *colstat;
                         pivot = mat[l];                          pivot = mat[l];
                         for ( i = 0; i < l; i++ ) {                          for ( i = 0; i < l; i++ ) {
                                 t = mat[i];                                  t = mat[i];
                                 if ( a = t[j] ) {                                  if ( a = t[j] )
                                         a = md-a; pk = pivot+j; tk = t+j;                                          red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);
                                         k = col-j;  
                                         for ( ; k >= 64; k -= 64 ) {  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2  
                                         }  
                                         for ( ; k >= 0; k -- ) {  
                                                 if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;  
                                         }  
                                 }  
                         }                          }
                         l--;                          l--;
                 }                  }
Line 1491  int *colstat;
Line 1788  int *colstat;
   
 /* LU decomposition; a[i][i] = 1/U[i][i] */  /* LU decomposition; a[i][i] = 1/U[i][i] */
   
 int lu_gfmmat(mat,md,perm)  int lu_gfmmat(GFMMAT mat,unsigned int md,int *perm)
 GFMMAT mat;  
 unsigned int md;  
 int *perm;  
 {  {
         int row,col;          int row,col;
         int i,j,k,l;          int i,j,k;
         unsigned int *t,*pivot;          unsigned int *t,*pivot;
         unsigned int **a;          unsigned int **a;
         unsigned int inv,m;          unsigned int inv,m;
Line 1549  int *perm;
Line 1843  int *perm;
         cinfo[j]=1 <=> j-th column is contained in the LU decomp.          cinfo[j]=1 <=> j-th column is contained in the LU decomp.
 */  */
   
 int find_lhs_and_lu_mod(a,row,col,md,rinfo,cinfo)  int find_lhs_and_lu_mod(unsigned int **a,int row,int col,
 unsigned int **a;          unsigned int md,int **rinfo,int **cinfo)
 unsigned int md;  
 int **rinfo,**cinfo;  
 {  {
         int i,j,k,l,d;          int i,j,k,d;
         int *rp,*cp;          int *rp,*cp;
         unsigned int *t,*pivot;          unsigned int *t,*pivot;
         unsigned int inv,m;          unsigned int inv,m;
Line 1602  int **rinfo,**cinfo;
Line 1894  int **rinfo,**cinfo;
         b = a^(-1)b          b = a^(-1)b
  */   */
   
 void solve_by_lu_mod(a,n,md,b,l)  void solve_by_lu_mod(int **a,int n,int md,int **b,int l)
 int **a;  
 int n;  
 int md;  
 int **b;  
 int l;  
 {  {
         unsigned int *y,*c;          unsigned int *y,*c;
         int i,j,k;          int i,j,k;
Line 1645  int l;
Line 1932  int l;
         }          }
 }  }
   
 void Pleqm1(arg,rp)  void Pleqm1(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         MAT m;          MAT m;
         VECT vect;          VECT vect;
Line 1686  VECT *rp;
Line 1971  VECT *rp;
         }          }
 }  }
   
 gauss_elim_mod1(mat,row,col,md)  int gauss_elim_mod1(int **mat,int row,int col,int md)
 int **mat;  
 int row,col,md;  
 {  {
         int i,j,k,inv,a,n;          int i,j,k,inv,a,n;
         int *t,*pivot;          int *t,*pivot;
Line 1725  int row,col,md;
Line 2008  int row,col,md;
                 return -1;                  return -1;
 }  }
   
 void Pgeninvm(arg,rp)  void Pgeninvm(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
         MAT m;          MAT m;
         pointer **mat;          pointer **mat;
Line 1761  LIST *rp;
Line 2042  LIST *rp;
                 MKMAT(mat1,col,row); MKMAT(mat2,row-col,row);                  MKMAT(mat1,col,row); MKMAT(mat2,row-col,row);
                 for ( i = 0, tmat = (Q **)mat1->body; i < col; i++ )                  for ( i = 0, tmat = (Q **)mat1->body; i < col; i++ )
                         for ( j = 0; j < row; j++ )                          for ( j = 0; j < row; j++ )
                                 STOQ(wmat[i][j+col],tmat[i][j]);                                  UTOQ(wmat[i][j+col],tmat[i][j]);
                 for ( tmat = (Q **)mat2->body; i < row; i++ )                  for ( tmat = (Q **)mat2->body; i < row; i++ )
                         for ( j = 0; j < row; j++ )                          for ( j = 0; j < row; j++ )
                                 STOQ(wmat[i][j+col],tmat[i-col][j]);                                  UTOQ(wmat[i][j+col],tmat[i-col][j]);
                 MKNODE(node2,mat2,0); MKNODE(node1,mat1,node2); MKLIST(*rp,node1);                  MKNODE(node2,mat2,0); MKNODE(node1,mat1,node2); MKLIST(*rp,node1);
         }          }
 }  }
   
 int gauss_elim_geninv_mod(mat,row,col,md)  int gauss_elim_geninv_mod(unsigned int **mat,int row,int col,int md)
 unsigned int **mat;  
 int row,col,md;  
 {  {
         int i,j,k,inv,a,n,m;          int i,j,k,inv,a,n,m;
         unsigned int *t,*pivot;          unsigned int *t,*pivot;
Line 1807  int row,col,md;
Line 2086  int row,col,md;
         return 0;          return 0;
 }  }
   
 void Psolve_by_lu_gfmmat(arg,rp)  void Psolve_by_lu_gfmmat(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         GFMMAT lu;          GFMMAT lu;
         Q *perm,*rhs,*v;          Q *perm,*rhs,*v;
Line 1830  VECT *rp;
Line 2107  VECT *rp;
         solve_by_lu_gfmmat(lu,md,b,sol);          solve_by_lu_gfmmat(lu,md,b,sol);
         MKVECT(r,n);          MKVECT(r,n);
         for ( i = 0, v = (Q *)r->body; i < n; i++ )          for ( i = 0, v = (Q *)r->body; i < n; i++ )
                         STOQ(sol[i],v[i]);                          UTOQ(sol[i],v[i]);
         *rp = r;          *rp = r;
 }  }
   
 void solve_by_lu_gfmmat(lu,md,b,x)  void solve_by_lu_gfmmat(GFMMAT lu,unsigned int md,
 GFMMAT lu;          unsigned int *b,unsigned int *x)
 unsigned int md;  
 unsigned int *b;  
 unsigned int *x;  
 {  {
         int n;          int n;
         unsigned int **a;          unsigned int **a;
Line 1870  unsigned int *x;
Line 2144  unsigned int *x;
         }          }
 }  }
   
 void Plu_gfmmat(arg,rp)  void Plu_gfmmat(NODE arg,LIST *rp)
 NODE arg;  
 LIST *rp;  
 {  {
         MAT m;          MAT m;
         GFMMAT mm;          GFMMAT mm;
Line 1902  LIST *rp;
Line 2174  LIST *rp;
         MKLIST(*rp,n0);          MKLIST(*rp,n0);
 }  }
   
 void Pmat_to_gfmmat(arg,rp)  void Pmat_to_gfmmat(NODE arg,GFMMAT *rp)
 NODE arg;  
 GFMMAT *rp;  
 {  {
         MAT m;          MAT m;
         unsigned int md;          unsigned int md;
Line 1915  GFMMAT *rp;
Line 2185  GFMMAT *rp;
         mat_to_gfmmat(m,md,rp);          mat_to_gfmmat(m,md,rp);
 }  }
   
 void mat_to_gfmmat(m,md,rp)  void mat_to_gfmmat(MAT m,unsigned int md,GFMMAT *rp)
 MAT m;  
 unsigned int md;  
 GFMMAT *rp;  
 {  {
         unsigned int **wmat;          unsigned int **wmat;
         unsigned int t;          unsigned int t;
Line 2044  int **indexp;
Line 2311  int **indexp;
         return 0;          return 0;
 }  }
   
   void Pgeninv_sf_swap(NODE arg,LIST *rp)
   {
           MAT m;
           GFS **mat,**tmat;
           Q *tvect;
           GFS q;
           int **wmat,**invmat;
           int *index;
           unsigned int t;
           int i,j,row,col,status;
           MAT mat1;
           VECT vect1;
           NODE node1,node2;
   
           asir_assert(ARG0(arg),O_MAT,"geninv_sf_swap");
           m = (MAT)ARG0(arg);
           row = m->row; col = m->col; mat = (GFS **)m->body;
           wmat = (int **)almat(row,col+row);
           for ( i = 0; i < row; i++ ) {
                   bzero((char *)wmat[i],(col+row)*sizeof(int));
                   for ( j = 0; j < col; j++ )
                           if ( q = (GFS)mat[i][j] )
                                   wmat[i][j] = FTOIF(CONT(q));
                   wmat[i][col+i] = _onesf();
           }
           status = gauss_elim_geninv_sf_swap(wmat,row,col,&invmat,&index);
           if ( status > 0 )
                   *rp = 0;
           else {
                   MKMAT(mat1,col,col);
                   for ( i = 0, tmat = (GFS **)mat1->body; i < col; i++ )
                           for ( j = 0; j < col; j++ )
                                   if ( t = invmat[i][j] ) {
                                           MKGFS(IFTOF(t),tmat[i][j]);
                                   }
                   MKVECT(vect1,row);
                   for ( i = 0, tvect = (Q *)vect1->body; i < row; i++ )
                           STOQ(index[i],tvect[i]);
                   MKNODE(node2,vect1,0); MKNODE(node1,mat1,node2); MKLIST(*rp,node1);
           }
   }
   
   int gauss_elim_geninv_sf_swap(int **mat,int row,int col,
           int ***invmatp,int **indexp)
   {
           int i,j,k,inv,a,n,m,u;
           int *t,*pivot,*s;
           int *index;
           int **invmat;
   
           n = col; m = row+col;
           *indexp = index = (int *)MALLOC_ATOMIC(row*sizeof(int));
           for ( i = 0; i < row; i++ )
                   index[i] = i;
           for ( j = 0; j < n; j++ ) {
                   for ( i = j; i < row && !mat[i][j]; i++ );
                   if ( i == row ) {
                           *indexp = 0; *invmatp = 0; return 1;
                   }
                   if ( i != j ) {
                           t = mat[i]; mat[i] = mat[j]; mat[j] = t;
                           k = index[i]; index[i] = index[j]; index[j] = k;
                   }
                   pivot = mat[j];
                   inv = _invsf(pivot[j]);
                   for ( k = j; k < m; k++ )
                           if ( pivot[k] )
                                   pivot[k] = _mulsf(pivot[k],inv);
                   for ( i = j+1; i < row; i++ ) {
                           t = mat[i];
                           if ( a = t[j] )
                                   for ( k = j, a = _chsgnsf(a); k < m; k++ )
                                           if ( pivot[k] ) {
                                                   u = _mulsf(pivot[k],a);
                                                   t[k] = _addsf(u,t[k]);
                                           }
                   }
           }
           for ( j = n-1; j >= 0; j-- ) {
                   pivot = mat[j];
                   for ( i = j-1; i >= 0; i-- ) {
                           t = mat[i];
                           if ( a = t[j] )
                                   for ( k = j, a = _chsgnsf(a); k < m; k++ )
                                           if ( pivot[k] ) {
                                                   u = _mulsf(pivot[k],a);
                                                   t[k] = _addsf(u,t[k]);
                                           }
                   }
           }
           *invmatp = invmat = (int **)almat(col,col);
           for ( i = 0; i < col; i++ )
                   for ( j = 0, s = invmat[i], t = mat[i]; j < col; j++ )
                           s[j] = t[col+index[j]];
           return 0;
   }
   
 void _addn(N,N,N);  void _addn(N,N,N);
 int _subn(N,N,N);  int _subn(N,N,N);
 void _muln(N,N,N);  void _muln(N,N,N);
   
 void inner_product_int(a,b,n,r)  void inner_product_int(Q *a,Q *b,int n,Q *r)
 Q *a,*b;  
 int n;  
 Q *r;  
 {  {
         int la,lb,i;          int la,lb,i;
         int sgn,sgn1;          int sgn,sgn1;
Line 2104  Q *r;
Line 2465  Q *r;
   
 /* (k,l) element of a*b where a: .x n matrix, b: n x . integer matrix */  /* (k,l) element of a*b where a: .x n matrix, b: n x . integer matrix */
   
 void inner_product_mat_int_mod(a,b,n,k,l,r)  void inner_product_mat_int_mod(Q **a,int **b,int n,int k,int l,Q *r)
 Q **a;  
 int **b;  
 int n,k,l;  
 Q *r;  
 {  {
         int la,lb,i;          int la,lb,i;
         int sgn,sgn1;          int sgn,sgn1;
Line 2164  Q *r;
Line 2521  Q *r;
                 NTOQ(sum,sgn,*r);                  NTOQ(sum,sgn,*r);
 }  }
   
 void Pmul_mat_vect_int(arg,rp)  void Pmul_mat_vect_int(NODE arg,VECT *rp)
 NODE arg;  
 VECT *rp;  
 {  {
         MAT mat;          MAT mat;
         VECT vect,r;          VECT vect,r;
Line 2177  VECT *rp;
Line 2532  VECT *rp;
         row = mat->row;          row = mat->row;
         col = mat->col;          col = mat->col;
         MKVECT(r,row);          MKVECT(r,row);
         for ( i = 0; i < row; i++ )          for ( i = 0; i < row; i++ ) {
                 inner_product_int(mat->body[i],vect->body,col,&r->body[i]);                  inner_product_int((Q *)mat->body[i],(Q *)vect->body,col,(Q *)&r->body[i]);
           }
         *rp = r;          *rp = r;
 }  }
   
 void Pnbpoly_up2(arg,rp)  void Pnbpoly_up2(NODE arg,GF2N *rp)
 NODE arg;  
 GF2N *rp;  
 {  {
         int m,type,ret;          int m,type,ret;
         UP2 r;          UP2 r;
Line 2198  GF2N *rp;
Line 2552  GF2N *rp;
                 *rp = 0;                  *rp = 0;
 }  }
   
 void Px962_irredpoly_up2(arg,rp)  void Px962_irredpoly_up2(NODE arg,GF2N *rp)
 NODE arg;  
 GF2N *rp;  
 {  {
         int m,type,ret,w;          int m,ret,w;
         GF2N prev;          GF2N prev;
         UP2 r;          UP2 r;
   
Line 2218  GF2N *rp;
Line 2570  GF2N *rp;
                         bzero((char *)r->b,w*sizeof(unsigned int));                          bzero((char *)r->b,w*sizeof(unsigned int));
                 }                  }
         }          }
         ret = _generate_irreducible_polynomial(r,m,type);          ret = _generate_irreducible_polynomial(r,m);
         if ( ret == 0 )          if ( ret == 0 )
                 MKGF2N(r,*rp);                  MKGF2N(r,*rp);
         else          else
                 *rp = 0;                  *rp = 0;
 }  }
   
 void Pirredpoly_up2(arg,rp)  void Pirredpoly_up2(NODE arg,GF2N *rp)
 NODE arg;  
 GF2N *rp;  
 {  {
         int m,type,ret,w;          int m,ret,w;
         GF2N prev;          GF2N prev;
         UP2 r;          UP2 r;
   
Line 2245  GF2N *rp;
Line 2595  GF2N *rp;
                         bzero((char *)r->b,w*sizeof(unsigned int));                          bzero((char *)r->b,w*sizeof(unsigned int));
                 }                  }
         }          }
         ret = _generate_good_irreducible_polynomial(r,m,type);          ret = _generate_good_irreducible_polynomial(r,m);
         if ( ret == 0 )          if ( ret == 0 )
                 MKGF2N(r,*rp);                  MKGF2N(r,*rp);
         else          else
                 *rp = 0;                  *rp = 0;
 }  }
   
   void Pmat_swap_row_destructive(NODE arg, MAT *m)
   {
           int i1,i2;
           pointer *t;
           MAT mat;
   
           asir_assert(ARG0(arg),O_MAT,"mat_swap_row_destructive");
           asir_assert(ARG1(arg),O_N,"mat_swap_row_destructive");
           asir_assert(ARG2(arg),O_N,"mat_swap_row_destructive");
           mat = (MAT)ARG0(arg);
           i1 = QTOS((Q)ARG1(arg));
           i2 = QTOS((Q)ARG2(arg));
           if ( i1 < 0 || i2 < 0 || i1 >= mat->row || i2 >= mat->row )
                   error("mat_swap_row_destructive : Out of range");
           t = mat->body[i1];
           mat->body[i1] = mat->body[i2];
           mat->body[i2] = t;
           *m = mat;
   }
   
   void Pmat_swap_col_destructive(NODE arg, MAT *m)
   {
           int j1,j2,i,n;
           pointer *mi;
           pointer t;
           MAT mat;
   
           asir_assert(ARG0(arg),O_MAT,"mat_swap_col_destructive");
           asir_assert(ARG1(arg),O_N,"mat_swap_col_destructive");
           asir_assert(ARG2(arg),O_N,"mat_swap_col_destructive");
           mat = (MAT)ARG0(arg);
           j1 = QTOS((Q)ARG1(arg));
           j2 = QTOS((Q)ARG2(arg));
           if ( j1 < 0 || j2 < 0 || j1 >= mat->col || j2 >= mat->col )
                   error("mat_swap_col_destructive : Out of range");
           n = mat->row;
           for ( i = 0; i < n; i++ ) {
                   mi = mat->body[i];
                   t = mi[j1]; mi[j1] = mi[j2]; mi[j2] = t;
           }
           *m = mat;
   }
 /*  /*
  * f = type 'type' normal polynomial of degree m if exists   * f = type 'type' normal polynomial of degree m if exists
  * IEEE P1363 A.7.2   * IEEE P1363 A.7.2
Line 2525  PENTA:
Line 2917  PENTA:
         return 1;          return 1;
 }  }
   
 printqmat(mat,row,col)  void printqmat(Q **mat,int row,int col)
 Q **mat;  
 int row,col;  
 {  {
         int i,j;          int i,j;
   
Line 2539  int row,col;
Line 2929  int row,col;
         }          }
 }  }
   
 printimat(mat,row,col)  void printimat(int **mat,int row,int col)
 int **mat;  
 int row,col;  
 {  {
         int i,j;          int i,j;
   
Line 2551  int row,col;
Line 2939  int row,col;
                 }                  }
                 printf("\n");                  printf("\n");
         }          }
   }
   
   void Pnd_det(NODE arg,P *rp)
   {
           if ( argc(arg) == 1 )
                   nd_det(0,ARG0(arg),rp);
           else
                   nd_det(QTOS((Q)ARG1(arg)),ARG0(arg),rp);
 }  }
Legend:
Removed from v.1.14  
changed lines
  Added in v.1.43
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>