[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.1 and 1.21

version 1.1, 1999/12/03 07:39:07 version 1.21, 2001/09/17 07:16:58
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir99/builtin/array.c,v 1.2 1999/11/23 07:14:14 noro Exp $ */  /*
    * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    *
    * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.20 2001/09/17 03:33:57 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"
 /*  
   #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);
 */  #endif
   
 extern int 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 *);  void solve_by_lu_gfmmat(GFMMAT,unsigned int,unsigned int *,unsigned int *);
 int lu_gfmmat(GFMMAT,unsigned int,int *);  int lu_gfmmat(GFMMAT,unsigned int,int *);
 void mat_to_gfmmat(MAT,unsigned int,GFMMAT *);  void mat_to_gfmmat(MAT,unsigned int,GFMMAT *);
   
 int generic_gauss_elim_mod(int **,int,int,int,int *);  int generic_gauss_elim_mod(int **,int,int,int,int *);
 int generic_gauss_elim(MAT ,MAT *,Q *,int **,int **);  int generic_gauss_elim(MAT ,MAT *,Q *,int **,int **);
   void reduce_sp_by_red_mod_compress (int *,CDP *,int *,int,int,int);
   
 int gauss_elim_mod(int **,int,int,int);  int gauss_elim_mod(int **,int,int,int);
 int gauss_elim_mod1(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(unsigned int **,int,int,int);
 int gauss_elim_geninv_mod_swap(unsigned int **,int,int,unsigned int,unsigned 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 Pnewbytearray();
   
 void Pgeneric_gauss_elim_mod();  void Pgeneric_gauss_elim_mod();
   
Line 38  void Px962_irredpoly_up2();
Line 91  void Px962_irredpoly_up2();
 void Pirredpoly_up2();  void Pirredpoly_up2();
 void Pnbpoly_up2();  void Pnbpoly_up2();
 void Pqsort();  void Pqsort();
   void Pexponent_vector();
   
 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 45  struct ftab array_tab[] = {
Line 99  struct ftab array_tab[] = {
         {"mat_to_gfmmat",Pmat_to_gfmmat,2},          {"mat_to_gfmmat",Pmat_to_gfmmat,2},
         {"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},          {"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},
         {"newvect",Pnewvect,-2},          {"newvect",Pnewvect,-2},
           {"vector",Pnewvect,-2},
           {"exponent_vector",Pexponent_vector,-99999999},
         {"newmat",Pnewmat,-3},          {"newmat",Pnewmat,-3},
           {"matrix",Pnewmat,-3},
           {"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},
Line 306  VECT *rp;
Line 364  VECT *rp;
   
         asir_assert(ARG0(arg),O_N,"newvect");          asir_assert(ARG0(arg),O_N,"newvect");
         len = QTOS((Q)ARG0(arg));          len = QTOS((Q)ARG0(arg));
         if ( len <= 0 )          if ( len < 0 )
                 error("newvect : invalid size");                  error("newvect : invalid size");
         MKVECT(vect,len);          MKVECT(vect,len);
         if ( argc(arg) == 2 ) {          if ( argc(arg) == 2 ) {
Line 323  VECT *rp;
Line 381  VECT *rp;
         *rp = vect;          *rp = vect;
 }  }
   
   void Pexponent_vector(arg,rp)
   NODE arg;
   DP *rp;
   {
           nodetod(arg,rp);
   }
   
   void Pnewbytearray(arg,rp)
   NODE arg;
   BYTEARRAY *rp;
   {
           int len,i,r;
           BYTEARRAY array;
           unsigned char *vb;
           char *str;
           LIST list;
           NODE tn;
   
           asir_assert(ARG0(arg),O_N,"newbytearray");
           len = QTOS((Q)ARG0(arg));
           if ( len < 0 )
                   error("newbytearray : invalid size");
           MKBYTEARRAY(array,len);
           if ( argc(arg) == 2 ) {
                   if ( !ARG1(arg) )
                           error("newbytearray : invalid initialization");
                   switch ( OID((Obj)ARG1(arg)) ) {
                           case O_LIST:
                                   list = (LIST)ARG1(arg);
                                   asir_assert(list,O_LIST,"newbytearray");
                                   for ( r = 0, tn = BDY(list); tn; r++, tn = NEXT(tn) );
                                   if ( r <= len ) {
                                           for ( i = 0, tn = BDY(list), vb = BDY(array); tn;
                                                   i++, tn = NEXT(tn) )
                                                   vb[i] = (unsigned char)QTOS((Q)BDY(tn));
                                   }
                                   break;
                           case O_STR:
                                   str = BDY((STRING)ARG1(arg));
                                   r = strlen(str);
                                   if ( r <= len )
                                           bcopy(str,BDY(array),r);
                                   break;
                           default:
                                   if ( !ARG1(arg) )
                                           error("newbytearray : invalid initialization");
                   }
           }
           *rp = array;
   }
   
 void Pnewmat(arg,rp)  void Pnewmat(arg,rp)
 NODE arg;  NODE arg;
 MAT *rp;  MAT *rp;
Line 337  MAT *rp;
Line 446  MAT *rp;
         asir_assert(ARG0(arg),O_N,"newmat");          asir_assert(ARG0(arg),O_N,"newmat");
         asir_assert(ARG1(arg),O_N,"newmat");          asir_assert(ARG1(arg),O_N,"newmat");
         row = QTOS((Q)ARG0(arg)); col = QTOS((Q)ARG1(arg));          row = QTOS((Q)ARG0(arg)); col = QTOS((Q)ARG1(arg));
         if ( row <= 0 || col <= 0 )          if ( row < 0 || col < 0 )
                 error("newmat : invalid size");                  error("newmat : invalid size");
         MKMAT(m,row,col);          MKMAT(m,row,col);
         if ( argc(arg) == 3 ) {          if ( argc(arg) == 3 ) {
Line 661  int row,col,md;
Line 770  int row,col,md;
                         t = mat[i];                          t = mat[i];
                         if ( i != j && (a = t[j]) )                          if ( i != j && (a = t[j]) )
                                 for ( k = j, a = md - a; k <= n; k++ ) {                                  for ( k = j, a = md - a; k <= n; k++ ) {
                                           unsigned int tk;
 /*                                      t[k] = dmar(pivot[k],a,t[k],md); */  /*                                      t[k] = dmar(pivot[k],a,t[k],md); */
                                         DMAR(pivot[k],a,t[k],md,t[k])                                          DMAR(pivot[k],a,t[k],md,tk)
                                           t[k] = tk;
                                 }                                  }
                 }                  }
         }          }
Line 673  int row,col,md;
Line 784  int row,col,md;
                 return -1;                  return -1;
 }  }
   
 struct oEGT eg_mod,eg_elim,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;
   
 int generic_gauss_elim(mat,nm,dn,rindp,cindp)  int generic_gauss_elim(mat,nm,dn,rindp,cindp)
 MAT mat;  MAT mat;
Line 706  int **rindp,**cindp;
Line 817  int **rindp,**cindp;
         colstat = (int *)MALLOC_ATOMIC(col*sizeof(int));          colstat = (int *)MALLOC_ATOMIC(col*sizeof(int));
         wcolstat = (int *)MALLOC_ATOMIC(col*sizeof(int));          wcolstat = (int *)MALLOC_ATOMIC(col*sizeof(int));
         for ( ind = 0; ; ind++ ) {          for ( ind = 0; ; ind++ ) {
                 if ( Print )                  if ( DP_Print ) {
                         fprintf(asir_out,".");                          fprintf(asir_out,"."); fflush(asir_out);
                 md = lprime[ind];                  }
                   md = get_lprime(ind);
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 for ( i = 0; i < row; i++ )                  for ( i = 0; i < row; i++ )
                         for ( j = 0, bmi = bmat[i], wmi = wmat[i]; j < col; j++ )                          for ( j = 0, bmi = bmat[i], wmi = wmat[i]; j < col; j++ )
Line 742  RESET:
Line 854  RESET:
                                         }                                          }
                 } else {                  } else {
                         if ( rank < rank0 ) {                          if ( rank < rank0 ) {
                                 if ( Print )                                  if ( DP_Print ) {
                                         fprintf(asir_out,"lower rank matrix; continuing...\n");                                          fprintf(asir_out,"lower rank matrix; continuing...\n");
                                           fflush(asir_out);
                                   }
                                 continue;                                  continue;
                         } else if ( rank > rank0 ) {                          } else if ( rank > rank0 ) {
                                 if ( Print )                                  if ( DP_Print ) {
                                         fprintf(asir_out,"higher rank matrix; resetting...\n");                                          fprintf(asir_out,"higher rank matrix; resetting...\n");
                                           fflush(asir_out);
                                   }
                                 goto RESET;                                  goto RESET;
                         } else {                          } else {
                                 for ( j = 0; (j<col) && (colstat[j]==wcolstat[j]); j++ );                                  for ( j = 0; (j<col) && (colstat[j]==wcolstat[j]); j++ );
                                 if ( j < col ) {                                  if ( j < col ) {
                                         if ( Print )                                          if ( DP_Print ) {
                                                 fprintf(asir_out,"inconsitent colstat; resetting...\n");                                                  fprintf(asir_out,"inconsitent colstat; resetting...\n");
                                                   fflush(asir_out);
                                           }
                                         goto RESET;                                          goto RESET;
                                 }                                  }
                         }                          }
Line 789  RESET:
Line 907  RESET:
                         add_eg(&eg_chrem_split,&tmp0,&tmp1);                          add_eg(&eg_chrem_split,&tmp0,&tmp1);
   
                         get_eg(&tmp0);                          get_eg(&tmp0);
                         ret = intmtoratm(crmat,m1,*nm,dn);                          if ( ind % 16 )
                                   ret = 0;
                           else
                                   ret = intmtoratm(crmat,m1,*nm,dn);
                         get_eg(&tmp1);                          get_eg(&tmp1);
                         add_eg(&eg_intrat,&tmp0,&tmp1);                          add_eg(&eg_intrat,&tmp0,&tmp1);
                         add_eg(&eg_intrat_split,&tmp0,&tmp1);                          add_eg(&eg_intrat_split,&tmp0,&tmp1);
Line 802  RESET:
Line 923  RESET:
                                         else                                          else
                                                 cind[l++] = j;                                                  cind[l++] = j;
                                 get_eg(&tmp0);                                  get_eg(&tmp0);
                                 if ( gensolve_check(mat,*nm,*dn,rind,cind) )                                  if ( gensolve_check(mat,*nm,*dn,rind,cind) ) {
                                 get_eg(&tmp1);                                          get_eg(&tmp1);
                                 add_eg(&eg_gschk,&tmp0,&tmp1);                                          add_eg(&eg_gschk,&tmp0,&tmp1);
                                 add_eg(&eg_gschk_split,&tmp0,&tmp1);                                          add_eg(&eg_gschk_split,&tmp0,&tmp1);
                                 if ( Print ) {                                          if ( DP_Print ) {
                                         print_eg("Mod",&eg_mod_split);                                                  print_eg("Mod",&eg_mod_split);
                                         print_eg("Elim",&eg_elim_split);                                                  print_eg("Elim",&eg_elim_split);
                                         print_eg("ChRem",&eg_chrem_split);                                                  print_eg("ChRem",&eg_chrem_split);
                                         print_eg("IntRat",&eg_intrat_split);                                                  print_eg("IntRat",&eg_intrat_split);
                                         print_eg("Check",&eg_gschk_split);                                                  print_eg("Check",&eg_gschk_split);
                                         fflush(asir_out);                                                  fflush(asir_out);
                                           }
                                           return rank;
                                 }                                  }
                                 return rank;  
                         }                          }
                 }                  }
         }          }
 }  }
   
   int generic_gauss_elim_hensel(mat,nmmat,dn,rindp,cindp)
   MAT mat;
   MAT *nmmat;
   Q *dn;
   int **rindp,**cindp;
   {
           MAT bmat,xmat;
           Q **a0,**a,**b,**x,**nm;
           Q *ai,*bi,*xi;
           int row,col;
           int **w;
           int *wi;
           int **wc;
           Q mdq,q,s,u;
           N tn;
           int ind,md,i,j,k,l,li,ri,rank;
           unsigned int t;
           int *cinfo,*rinfo;
           int *rind,*cind;
           int count;
           struct oEGT eg_mul,eg_inv,tmp0,tmp1;
   
           a0 = (Q **)mat->body;
           row = mat->row; col = mat->col;
           w = (int **)almat(row,col);
           for ( ind = 0; ; ind++ ) {
                   md = get_lprime(ind);
                   STOQ(md,mdq);
                   for ( i = 0; i < row; i++ )
                           for ( j = 0, ai = a0[i], wi = w[i]; j < col; j++ )
                                   if ( q = (Q)ai[j] ) {
                                           t = rem(NM(q),md);
                                           if ( t && SGN(q) < 0 )
                                                   t = (md - t) % md;
                                           wi[j] = t;
                                   } else
                                           wi[j] = 0;
   
                   rank = find_lhs_and_lu_mod(w,row,col,md,&rinfo,&cinfo);
                   a = (Q **)almat_pointer(rank,rank); /* lhs mat */
                   MKMAT(bmat,rank,col-rank); b = (Q **)bmat->body; /* lhs mat */
                   for ( j = li = ri = 0; j < col; j++ )
                           if ( cinfo[j] ) {
                                   /* the column is in lhs */
                                   for ( i = 0; i < rank; i++ ) {
                                           w[i][li] = w[i][j];
                                           a[i][li] = a0[rinfo[i]][j];
                                   }
                                   li++;
                           } else {
                                   /* the column is in rhs */
                                   for ( i = 0; i < rank; i++ )
                                           b[i][ri] = a0[rinfo[i]][j];
                                   ri++;
                           }
   
                           /* solve Ax+B=0; A: rank x rank, B: rank x ri */
                           MKMAT(xmat,rank,ri); x = (Q **)(xmat)->body;
                           MKMAT(*nmmat,rank,ri); nm = (Q **)(*nmmat)->body;
                           /* use the right part of w as work area */
                           /* ri = col - rank */
                           wc = (int **)almat(rank,ri);
                           for ( i = 0; i < rank; i++ )
                                   wc[i] = w[i]+rank;
                           *rindp = rind = (int *)MALLOC_ATOMIC(rank*sizeof(int));
                           *cindp = cind = (int *)MALLOC_ATOMIC((ri)*sizeof(int));
   
                           init_eg(&eg_mul); init_eg(&eg_inv);
                           for ( q = ONE, count = 0; ; count++ ) {
                                   fprintf(stderr,".");
                                   /* wc = -b mod md */
                                   for ( i = 0; i < rank; i++ )
                                           for ( j = 0, bi = b[i], wi = wc[i]; j < ri; j++ )
                                                   if ( u = (Q)bi[j] ) {
                                                           t = rem(NM(u),md);
                                                           if ( t && SGN(u) > 0 )
                                                                   t = (md - t) % md;
                                                           wi[j] = t;
                                                   } else
                                                           wi[j] = 0;
                                   /* wc = A^(-1)wc; wc is normalized */
                                   get_eg(&tmp0);
                                   solve_by_lu_mod(w,rank,md,wc,ri);
                                   get_eg(&tmp1);
                                   add_eg(&eg_inv,&tmp0,&tmp1);
                                   /* x = x-q*wc */
                                   for ( i = 0; i < rank; i++ )
                                           for ( j = 0, xi = x[i], wi = wc[i]; j < ri; j++ ) {
                                                   STOQ(wi[j],u); mulq(q,u,&s);
                                                   subq(xi[j],s,&u); xi[j] = u;
                                           }
                                   get_eg(&tmp0);
                                   for ( i = 0; i < rank; i++ )
                                           for ( j = 0; j < ri; j++ ) {
                                                   inner_product_mat_int_mod(a,wc,rank,i,j,&u);
                                                   addq(b[i][j],u,&s);
                                                   if ( s ) {
                                                           t = divin(NM(s),md,&tn);
                                                           if ( t )
                                                                   error("generic_gauss_elim_hensel:incosistent");
                                                           NTOQ(tn,SGN(s),b[i][j]);
                                                   } else
                                                           b[i][j] = 0;
                                           }
                                   get_eg(&tmp1);
                                   add_eg(&eg_mul,&tmp0,&tmp1);
                                   /* q = q*md */
                                   mulq(q,mdq,&u); q = u;
                                   if ( !(count % 16) && intmtoratm_q(xmat,NM(q),*nmmat,dn) ) {
                                           for ( j = k = l = 0; j < col; j++ )
                                                   if ( cinfo[j] )
                                                           rind[k++] = j;
                                                   else
                                                           cind[l++] = j;
                                           if ( gensolve_check(mat,*nmmat,*dn,rind,cind) ) {
                                                   fprintf(stderr,"\n");
                                                   print_eg("INV",&eg_inv);
                                                   print_eg("MUL",&eg_mul);
                                                   fflush(asir_out);
                                                   return rank;
                                           }
                                   }
                           }
           }
   }
   
 int f4_nocheck;  int f4_nocheck;
   
 int gensolve_check(mat,nm,dn,rind,cind)  int gensolve_check(mat,nm,dn,rind,cind)
Line 914  Q *dn;
Line 1162  Q *dn;
         N u,unm,udn;          N u,unm,udn;
         int sgn,ret;          int sgn,ret;
   
           if ( UNIN(md) )
                   return 0;
         row = mat->row; col = mat->col;          row = mat->row; col = mat->col;
         bshiftn(md,1,&t);          bshiftn(md,1,&t);
         isqrt(t,&s);          isqrt(t,&s);
Line 951  Q *dn;
Line 1201  Q *dn;
         return 1;          return 1;
 }  }
   
 int generic_gauss_elim_mod(mat,row,col,md,colstat)  /* mat->body = Q ** */
   
   int intmtoratm_q(mat,md,nm,dn)
   MAT mat;
   N md;
   MAT nm;
   Q *dn;
   {
           N t,s,b;
           Q bound,dn0,dn1,nm1,q,tq;
           int i,j,k,l,row,col;
           Q **rmat;
           Q **tmat;
           Q *tmi;
           Q *nmk;
           N u,unm,udn;
           int sgn,ret;
   
           if ( UNIN(md) )
                   return 0;
           row = mat->row; col = mat->col;
           bshiftn(md,1,&t);
           isqrt(t,&s);
           bshiftn(s,64,&b);
           if ( !b )
                   b = ONEN;
           dn0 = ONE;
           tmat = (Q **)mat->body;
           rmat = (Q **)nm->body;
           for ( i = 0; i < row; i++ )
                   for ( j = 0, tmi = tmat[i]; j < col; j++ )
                           if ( tmi[j] ) {
                                   muln(NM(tmi[j]),NM(dn0),&s);
                                   remn(s,md,&u);
                                   ret = inttorat(u,md,b,&sgn,&unm,&udn);
                                   if ( !ret )
                                           return 0;
                                   else {
                                           if ( SGN(tmi[j])<0 )
                                                   sgn = -sgn;
                                           NTOQ(unm,sgn,nm1);
                                           NTOQ(udn,1,dn1);
                                           if ( !UNIQ(dn1) ) {
                                                   for ( k = 0; k < i; k++ )
                                                           for ( l = 0, nmk = rmat[k]; l < col; l++ ) {
                                                                   mulq(nmk[l],dn1,&q); nmk[l] = q;
                                                           }
                                                   for ( l = 0, nmk = rmat[i]; l < j; l++ ) {
                                                           mulq(nmk[l],dn1,&q); nmk[l] = q;
                                                   }
                                           }
                                           rmat[i][j] = nm1;
                                           mulq(dn0,dn1,&q); dn0 = q;
                                   }
                           }
           *dn = dn0;
           return 1;
   }
   
   #define ONE_STEP1  if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;
   
   void reduce_reducers_mod(mat,row,col,md)
 int **mat;  int **mat;
   int row,col;
   int md;
   {
           int i,j,k,l,hc,zzz;
           int *t,*s,*tj,*ind;
   
           /* reduce the reducers */
           ind = (int *)ALLOCA(row*sizeof(int));
           for ( i = 0; i < row; i++ ) {
                   t = mat[i];
                   for ( j = 0; j < col && !t[j]; j++ );
                   /* register the position of the head term */
                   ind[i] = j;
                   for ( l = i-1; l >= 0; l-- ) {
                           /* reduce mat[i] by mat[l] */
                           if ( hc = t[ind[l]] ) {
                                   /* mat[i] = mat[i]-hc*mat[l] */
                                   j = ind[l];
                                   s = mat[l]+j;
                                   tj = t+j;
                                   hc = md-hc;
                                   k = col-j;
                                   for ( ; k >= 64; k -= 64 ) {
                                           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
                                           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
                                           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
                                           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-- ) {
                                           if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;
                                   }
                           }
                   }
           }
   }
   
   /*
           mat[i] : reducers (i=0,...,nred-1)
                    spolys (i=nred,...,row-1)
           mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order
           1. reduce the reducers
           2. reduce spolys by the reduced reducers
   */
   
   void pre_reduce_mod(mat,row,col,nred,md)
   int **mat;
   int row,col,nred;
   int md;
   {
           int i,j,k,l,hc,inv;
           int *t,*s,*tk,*ind;
   
   #if 1
           /* reduce the reducers */
           ind = (int *)ALLOCA(row*sizeof(int));
           for ( i = 0; i < nred; i++ ) {
                   /* make mat[i] monic and mat[i] by mat[0],...,mat[i-1] */
                   t = mat[i];
                   for ( j = 0; j < col && !t[j]; j++ );
                   /* register the position of the head term */
                   ind[i] = j;
                   inv = invm(t[j],md);
                   for ( k = j; k < col; k++ )
                           if ( t[k] )
                                   DMAR(t[k],inv,0,md,t[k])
                   for ( l = i-1; l >= 0; l-- ) {
                           /* reduce mat[i] by mat[l] */
                           if ( hc = t[ind[l]] ) {
                                   /* mat[i] = mat[i]-hc*mat[l] */
                                   for ( k = ind[l], hc = md-hc, s = mat[l]+k, tk = t+k;
                                           k < col; k++, tk++, s++ )
                                           if ( *s )
                                                   DMAR(*s,hc,*tk,md,*tk)
                           }
                   }
           }
           /* reduce the spolys */
           for ( i = nred; i < row; i++ ) {
                   t = mat[i];
                   for ( l = nred-1; l >= 0; l-- ) {
                           /* reduce mat[i] by mat[l] */
                           if ( hc = t[ind[l]] ) {
                                   /* mat[i] = mat[i]-hc*mat[l] */
                                   for ( k = ind[l], hc = md-hc, s = mat[l]+k, tk = t+k;
                                           k < col; k++, tk++, s++ )
                                           if ( *s )
                                                   DMAR(*s,hc,*tk,md,*tk)
                           }
                   }
           }
   #endif
   }
   /*
           mat[i] : reducers (i=0,...,nred-1)
           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)
   int *sp,**redmat;
   int *ind;
   int nred,col;
   int md;
   {
           int i,j,k,hc,zzz;
           int *t,*s,*tj;
   
           /* reduce the spolys by redmat */
           for ( i = nred-1; i >= 0; i-- ) {
                   /* reduce sp by redmat[i] */
                   if ( hc = sp[ind[i]] ) {
                           /* sp = sp-hc*redmat[i] */
                           j = ind[i];
                           hc = md-hc;
                           s = redmat[i]+j;
                           tj = sp+j;
                           for ( k = col-j; k > 0; k-- ) {
                                   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
   */
   
   int red_by_compress(m,p,r,ri,hc,len)
   int m;
   unsigned int *p;
   register unsigned int *r;
   register unsigned short *ri;
   unsigned int hc;
   register 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 */
   
   int red_by_vect(m,p,r,hc,len)
   int m;
   unsigned int *p,*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;
                   }
   }
   
   extern unsigned int **psca;
   
   void reduce_sp_by_red_mod_compress (sp,redmat,ind,nred,col,md)
   int *sp;
   CDP *redmat;
   int *ind;
   int nred,col;
   int md;
   {
           int i,j,k,len;
           unsigned int *tj;
           CDP ri;
           unsigned int hc,up,lo,up1,lo1,c;
           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] >= md )
                           usp[i] %= md;
   }
   
   #define ONE_STEP2  if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;
   
   int generic_gauss_elim_mod(mat0,row,col,md,colstat)
   int **mat0;
 int row,col,md;  int row,col,md;
 int *colstat;  int *colstat;
 {  {
         int i,j,k,l,inv,a,rank;          int i,j,k,l,inv,a,rank,zzz;
         int *t,*pivot;          unsigned int *t,*pivot,*pk,*tk;
           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 971  int *colstat;
Line 1509  int *colstat;
                 }                  }
                 pivot = mat[rank];                  pivot = mat[rank];
                 inv = invm(pivot[j],md);                  inv = invm(pivot[j],md);
                 for ( k = j; k < col; k++ )                  for ( k = j, pk = pivot+k; k < col; k++, pk++ )
                         if ( pivot[k] ) {                          if ( *pk ) {
                                 DMAR(pivot[k],inv,0,md,pivot[k])                                  if ( *pk >= md )
                                           *pk %= md;
                                   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] )
                                 for ( k = j, a = md - a; k < col; k++ )                                  red_by_vect(md,t+j,pivot+j,md-a,col-j);
                                         if ( pivot[k] ) {  
                                                 DMAR(pivot[k],a,t[k],md,t[k])  
                                         }  
                 }                  }
                 rank++;                  rank++;
         }          }
Line 990  int *colstat;
Line 1527  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];
                                   t[j] %= md;
                                 if ( a = t[j] )                                  if ( a = t[j] )
                                         for ( k = j, a = md-a; k < col; k++ )                                          red_by_vect(md,t+j,pivot+j,md-a,col-j);
                                                 if ( pivot[k] ) {  
                                                         DMAR(pivot[k],a,t[k],md,t[k])  
                                                 }  
                         }                          }
                         l--;                          l--;
                 }                  }
           for ( j = 0, l = 0; l < rank; j++ )
                   if ( colstat[j] ) {
                           t = mat[l];
                           for ( k = j; k < col; k++ )
                                   if ( t[k] >= md )
                                           t[k] %= md;
                           l++;
                   }
         return rank;          return rank;
 }  }
   
Line 1036  int *perm;
Line 1579  int *perm;
                                 DMAR(inv,m,0,md,t[k])                                  DMAR(inv,m,0,md,t[k])
                                 for ( j = k+1, m = md - t[k]; j < col; j++ )                                  for ( j = k+1, m = md - t[k]; j < col; j++ )
                                         if ( pivot[j] ) {                                          if ( pivot[j] ) {
                                                 DMAR(m,pivot[j],t[j],md,t[j])                                                  unsigned int tj;
   
                                                   DMAR(m,pivot[j],t[j],md,tj)
                                                   t[j] = tj;
                                         }                                          }
                         }                          }
                 }                  }
Line 1044  int *perm;
Line 1590  int *perm;
         return 1;          return 1;
 }  }
   
   /*
    Input
           a: a row x col matrix
           md : a modulus
   
    Output:
           return : d = the rank of mat
           a[0..(d-1)][0..(d-1)] : LU decomposition (a[i][i] = 1/U[i][i])
           rinfo: array of length row
           cinfo: array of length col
       i-th row in new a <-> rinfo[i]-th row in old a
           cinfo[j]=1 <=> j-th column is contained in the LU decomp.
   */
   
   int find_lhs_and_lu_mod(a,row,col,md,rinfo,cinfo)
   unsigned int **a;
   unsigned int md;
   int **rinfo,**cinfo;
   {
           int i,j,k,l,d;
           int *rp,*cp;
           unsigned int *t,*pivot;
           unsigned int inv,m;
   
           *rinfo = rp = (int *)MALLOC_ATOMIC(row*sizeof(int));
           *cinfo = cp = (int *)MALLOC_ATOMIC(col*sizeof(int));
           for ( i = 0; i < row; i++ )
                   rp[i] = i;
           for ( k = 0, d = 0; k < col; k++ ) {
                   for ( i = d; i < row && !a[i][k]; i++ );
                   if ( i == row ) {
                           cp[k] = 0;
                           continue;
                   } else
                           cp[k] = 1;
                   if ( i != d ) {
                           j = rp[i]; rp[i] = rp[d]; rp[d] = j;
                           t = a[i]; a[i] = a[d]; a[d] = t;
                   }
                   pivot = a[d];
                   pivot[k] = inv = invm(pivot[k],md);
                   for ( i = d+1; i < row; i++ ) {
                           t = a[i];
                           if ( m = t[k] ) {
                                   DMAR(inv,m,0,md,t[k])
                                   for ( j = k+1, m = md - t[k]; j < col; j++ )
                                           if ( pivot[j] ) {
                                                   unsigned int tj;
                                                   DMAR(m,pivot[j],t[j],md,tj)
                                                   t[j] = tj;
                                           }
                           }
                   }
                   d++;
           }
           return d;
   }
   
   /*
     Input
           a : n x n matrix; a result of LU-decomposition
           md : modulus
           b : n x l matrix
    Output
           b = a^(-1)b
    */
   
   void solve_by_lu_mod(a,n,md,b,l)
   int **a;
   int n;
   int md;
   int **b;
   int l;
   {
           unsigned int *y,*c;
           int i,j,k;
           unsigned int t,m,m2;
   
           y = (int *)MALLOC_ATOMIC(n*sizeof(int));
           c = (int *)MALLOC_ATOMIC(n*sizeof(int));
           m2 = md>>1;
           for ( k = 0; k < l; k++ ) {
                   /* copy b[.][k] to c */
                   for ( i = 0; i < n; i++ )
                           c[i] = (unsigned int)b[i][k];
                   /* solve Ly=c */
                   for ( i = 0; i < n; i++ ) {
                           for ( t = c[i], j = 0; j < i; j++ )
                                   if ( a[i][j] ) {
                                           m = md - a[i][j];
                                           DMAR(m,y[j],t,md,t)
                                   }
                           y[i] = t;
                   }
                   /* solve Uc=y */
                   for ( i = n-1; i >= 0; i-- ) {
                           for ( t = y[i], j =i+1; j < n; j++ )
                                   if ( a[i][j] ) {
                                           m = md - a[i][j];
                                           DMAR(m,c[j],t,md,t)
                                   }
                           /* a[i][i] = 1/U[i][i] */
                           DMAR(t,a[i][i],0,md,c[i])
                   }
                   /* copy c to b[.][k] with normalization */
                   for ( i = 0; i < n; i++ )
                           b[i][k] = (int)(c[i]>m2 ? c[i]-md : c[i]);
           }
   }
   
 void Pleqm1(arg,rp)  void Pleqm1(arg,rp)
 NODE arg;  NODE arg;
 VECT *rp;  VECT *rp;
Line 1501  Q *r;
Line 2157  Q *r;
                 NTOQ(sum,sgn,*r);                  NTOQ(sum,sgn,*r);
 }  }
   
   /* (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)
   Q **a;
   int **b;
   int n,k,l;
   Q *r;
   {
           int la,lb,i;
           int sgn,sgn1;
           N wm,wma,sum,t;
           Q aki;
           int bil,bilsgn;
           struct oN tn;
   
           for ( la = 0, i = 0; i < n; i++ ) {
                   if ( aki = a[k][i] )
                           if ( DN(aki) )
                                   error("inner_product_int : invalid argument");
                           else
                                   la = MAX(PL(NM(aki)),la);
           }
           lb = 1;
           sgn = 0;
           sum= NALLOC(la+lb+2);
           bzero((char *)sum,(la+lb+3)*sizeof(unsigned int));
           wm = NALLOC(la+lb+2);
           wma = NALLOC(la+lb+2);
           for ( i = 0; i < n; i++ ) {
                   if ( !(aki = a[k][i]) || !(bil = b[i][l]) )
                           continue;
                   tn.p = 1;
                   if ( bil > 0 ) {
                           tn.b[0] = bil; bilsgn = 1;
                   } else {
                           tn.b[0] = -bil; bilsgn = -1;
                   }
                   _muln(NM(aki),&tn,wm);
                   sgn1 = SGN(aki)*bilsgn;
                   if ( !sgn ) {
                           sgn = sgn1;
                           t = wm; wm = sum; sum = t;
                   } else if ( sgn == sgn1 ) {
                           _addn(sum,wm,wma);
                           if ( !PL(wma) )
                                   sgn = 0;
                           t = wma; wma = sum; sum = t;
                   } else {
                           /* sgn*sum+sgn1*wm = sgn*(sum-wm) */
                           sgn *= _subn(sum,wm,wma);
                           t = wma; wma = sum; sum = t;
                   }
           }
           GC_free(wm);
           GC_free(wma);
           if ( !sgn ) {
                   GC_free(sum);
                   *r = 0;
           } else
                   NTOQ(sum,sgn,*r);
   }
   
 void Pmul_mat_vect_int(arg,rp)  void Pmul_mat_vect_int(arg,rp)
 NODE arg;  NODE arg;
 VECT *rp;  VECT *rp;
Line 1860  PENTA:
Line 2578  PENTA:
         }          }
         /* exhausted */          /* exhausted */
         return 1;          return 1;
   }
   
   printqmat(mat,row,col)
   Q **mat;
   int row,col;
   {
           int i,j;
   
           for ( i = 0; i < row; i++ ) {
                   for ( j = 0; j < col; j++ ) {
                           printnum((Num)mat[i][j]); printf(" ");
                   }
                   printf("\n");
           }
   }
   
   printimat(mat,row,col)
   int **mat;
   int row,col;
   {
           int i,j;
   
           for ( i = 0; i < row; i++ ) {
                   for ( j = 0; j < col; j++ ) {
                           printf("%d ",mat[i][j]);
                   }
                   printf("\n");
           }
 }  }
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.21
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>