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

Diff for /OpenXM_contrib2/asir2000/engine/nd.c between version 1.224 and 1.244

version 1.224, 2016/03/31 01:40:10 version 1.244, 2018/03/05 06:43:09
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.223 2015/08/14 13:51:54 fujimoto Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.243 2018/03/05 01:56:17 noro Exp $ */
   
 #include "nd.h"  #include "nd.h"
   
Line 60  static int nd_module_rank,nd_poly_weight_len;
Line 60  static int nd_module_rank,nd_poly_weight_len;
 static int *nd_poly_weight,*nd_module_weight;  static int *nd_poly_weight,*nd_module_weight;
 static NODE nd_tracelist;  static NODE nd_tracelist;
 static NODE nd_alltracelist;  static NODE nd_alltracelist;
 static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect;  static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect,nd_lf;
 static int *nd_gbblock;  static int *nd_gbblock;
 static NODE nd_nzlist,nd_check_splist;  static NODE nd_nzlist,nd_check_splist;
 static int nd_splist;  static int nd_splist;
   static int *nd_sugarweight;
   static int nd_f4red,nd_rank0,nd_last_nonzero;
   
 NumberField get_numberfield();  NumberField get_numberfield();
 UINT *nd_det_compute_bound(NDV **dm,int n,int j);  UINT *nd_det_compute_bound(NDV **dm,int n,int j);
Line 93  ND ndgztond(ND p);
Line 95  ND ndgztond(ND p);
 void Pdp_set_weight(NODE,VECT *);  void Pdp_set_weight(NODE,VECT *);
 void Pox_cmo_rpc(NODE,Obj *);  void Pox_cmo_rpc(NODE,Obj *);
   
 extern int Denominator,DP_Multiple;  ND nd_add_lf(ND p1,ND p2);
   void nd_mul_c_lf(ND p,GZ mul);
   void ndv_mul_c_lf(NDV p,GZ mul);
   NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz);
   NODE nd_f4_red_mod64_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz);
   NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred);
   int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat);
   NODE nd_f4_lf_trace_main(int m,int **indp);
   void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp);
   
   extern int lf_lazy;
   extern GZ current_mod_lf;
   
   extern int Denominator,DP_Multiple,MaxDeg;
   
 #define BLEN (8*sizeof(unsigned long))  #define BLEN (8*sizeof(unsigned long))
   
 typedef struct matrix {  typedef struct matrix {
Line 173  INLINE int nd_length(ND p)
Line 191  INLINE int nd_length(ND p)
     }      }
 }  }
   
   extern int dp_negative_weight;
   
 INLINE int ndl_reducible(UINT *d1,UINT *d2)  INLINE int ndl_reducible(UINT *d1,UINT *d2)
 {  {
     UINT u1,u2;      UINT u1,u2;
Line 180  INLINE int ndl_reducible(UINT *d1,UINT *d2)
Line 200  INLINE int ndl_reducible(UINT *d1,UINT *d2)
   
     if ( nd_module && (MPOS(d1) != MPOS(d2)) ) return 0;      if ( nd_module && (MPOS(d1) != MPOS(d2)) ) return 0;
   
     if ( TD(d1) < TD(d2) ) return 0;      if ( !dp_negative_weight && TD(d1) < TD(d2) ) return 0;
 #if USE_UNROLL  #if USE_UNROLL
     switch ( nd_bpe ) {      switch ( nd_bpe ) {
         case 3:          case 3:
Line 459  int ndl_weight(UINT *d)
Line 479  int ndl_weight(UINT *d)
     return t;      return t;
 }  }
   
   /* for sugarweight */
   
   int ndl_weight2(UINT *d)
   {
       int t,u;
       int i,j;
   
       for ( i = 0, t = 0; i < nd_nvar; i++ ) {
           u = GET_EXP(d,i);
           t += nd_sugarweight[i]*u;
       }
       if ( nd_module && current_module_weight_vector && MPOS(d) )
           t += current_module_weight_vector[MPOS(d)];
       return t;
   }
   
 void ndl_weight_mask(UINT *d)  void ndl_weight_mask(UINT *d)
 {  {
     UINT t,u;      UINT t,u;
Line 620  int ndl_composite_compare(UINT *d1,UINT *d2)
Line 656  int ndl_composite_compare(UINT *d1,UINT *d2)
                             else if ( nd_work_vector[j] < 0 ) return -1;                              else if ( nd_work_vector[j] < 0 ) return -1;
                         break;                          break;
                     case 2:                      case 2:
                           end = start+len;
                         for ( j = start; j < end; j++ )                          for ( j = start; j < end; j++ )
                             if ( nd_work_vector[j] > 0 ) return 1;                              if ( nd_work_vector[j] > 0 ) return 1;
                             else if ( nd_work_vector[j] < 0 ) return -1;                              else if ( nd_work_vector[j] < 0 ) return -1;
Line 658  int ndl_module_weight_compare(UINT *d1,UINT *d2)
Line 695  int ndl_module_weight_compare(UINT *d1,UINT *d2)
   s = 0;    s = 0;
   for ( j = 0; j < nd_nvar; j++ )    for ( j = 0; j < nd_nvar; j++ )
      s += (GET_EXP(d1,j)-GET_EXP(d2,j))*nd_poly_weight[j];       s += (GET_EXP(d1,j)-GET_EXP(d2,j))*nd_poly_weight[j];
   s += nd_module_weight[MPOS(d1)-1]-nd_module_weight[MPOS(d2)-1];    if ( MPOS(d1) >= 1 && MPOS(d2) >= 1 ) {
       s += nd_module_weight[MPOS(d1)-1]-nd_module_weight[MPOS(d2)-1];
     }
   if ( s > 0 ) return 1;    if ( s > 0 ) return 1;
   else if ( s < 0 ) return -1;    else if ( s < 0 ) return -1;
   else return 0;    else return 0;
Line 668  int ndl_module_grlex_compare(UINT *d1,UINT *d2)
Line 707  int ndl_module_grlex_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
     if ( !MPOS(d1) || !MPOS(d2) ) {  
        printf("afo\n");  
     }  
   
     if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;      if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
                 if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) {                  if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) {
Line 1187  ND nd_add(int mod,ND p1,ND p2)
Line 1222  ND nd_add(int mod,ND p1,ND p2)
     if ( !p1 ) return p2;      if ( !p1 ) return p2;
     else if ( !p2 ) return p1;      else if ( !p2 ) return p1;
     else if ( mod == -1 ) return nd_add_sf(p1,p2);      else if ( mod == -1 ) return nd_add_sf(p1,p2);
       else if ( mod == -2 ) return nd_add_lf(p1,p2);
     else if ( !mod ) return nd_add_q(p1,p2);      else if ( !mod ) return nd_add_q(p1,p2);
     else {      else {
         can = 0;          can = 0;
Line 1347  ND nd_add_sf(ND p1,ND p2)
Line 1383  ND nd_add_sf(ND p1,ND p2)
     }      }
 }  }
   
   
 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Obj *divp)  ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Obj *divp)
 {  {
     int c,c1,c2;      int c,c1,c2;
Line 1357  ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob
Line 1394  ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob
     if ( mod == -1 ) {      if ( mod == -1 ) {
         CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));          CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));
         *divp = (Obj)ONE;          *divp = (Obj)ONE;
       } else if ( mod == -2 ) {
           GZ inv,t;
           divlf(ONEGZ,HCZ(p),&inv);
           chsgnlf(HCZ(g),&t);
           mullf(inv,t,&CZ(mul));
           *divp = (Obj)ONE;
     } else if ( mod ) {      } else if ( mod ) {
         c1 = invm(HCM(p),mod); c2 = mod-HCM(g);          c1 = invm(HCM(p),mod); c2 = mod-HCM(g);
         DMAR(c1,c2,0,mod,c); CM(mul) = c;          DMAR(c1,c2,0,mod,c); CM(mul) = c;
Line 1418  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
Line 1461  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
   
     sugar0 = sugar = SG(g);      sugar0 = sugar = SG(g);
     n = NV(g);      n = NV(g);
     mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));      mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));
     if ( d )      if ( d )
         for ( tail = BDY(d); NEXT(tail); tail = NEXT(tail) );          for ( tail = BDY(d); NEXT(tail); tail = NEXT(tail) );
     for ( ; g; ) {      for ( ; g; ) {
Line 1506  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
Line 1549  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
     bucket = create_pbucket();      bucket = create_pbucket();
     add_pbucket(mod,bucket,g);      add_pbucket(mod,bucket,g);
     d = 0;      d = 0;
     mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));      mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));
     while ( 1 ) {      while ( 1 ) {
         hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket);          if ( mod > 0 || mod == -1 )
             hindex = head_pbucket(mod,bucket);
           else if ( mod == -2 )
             hindex = head_pbucket_lf(bucket);
           else
             hindex = head_pbucket_q(bucket);
         if ( hindex < 0 ) {          if ( hindex < 0 ) {
             if ( DP_Print > 3 ) printf("(%d %d)",count,hcount);              if ( DP_Print > 3 ) printf("(%d %d)",count,hcount);
             if ( d ) SG(d) = sugar;              if ( d ) SG(d) = sugar;
Line 1531  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
Line 1579  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
             p = ps[index];              p = ps[index];
             if ( mod == -1 )              if ( mod == -1 )
                 CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));                  CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g)));
              else if ( mod ) {              else if ( mod == -2 ) {
                   GZ inv,t;
                   divlf(ONEGZ,HCZ(p),&inv);
                   chsgnlf(HCZ(g),&t);
                   mullf(inv,t,&CZ(mul));
               } else if ( mod ) {
                 c1 = invm(HCM(p),mod); c2 = mod-HCM(g);                  c1 = invm(HCM(p),mod); c2 = mod-HCM(g);
                 DMAR(c1,c2,0,mod,c); CM(mul) = c;                  DMAR(c1,c2,0,mod,c); CM(mul) = c;
             } else {              } else {
Line 1606  again:
Line 1659  again:
             r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos);              r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos);
         else          else
             r = (NDV)BDY(t);              r = (NDV)BDY(t);
           if ( m ) ndv_mod(m,r);
         d = ndvtond(m,r);          d = ndvtond(m,r);
         stat = nd_nf(m,0,d,nd_ps,0,0,&nf);          stat = nd_nf(m,0,d,nd_ps,0,0,&nf);
         if ( !stat ) {          if ( !stat ) {
Line 1839  int head_pbucket_q(PGeoBucket g)
Line 1893  int head_pbucket_q(PGeoBucket g)
     }      }
 }  }
   
   int head_pbucket_lf(PGeoBucket g)
   {
       int j,i,c,k,nv;
       GZ sum,t;
       ND gi,gj;
   
       k = g->m;
       while ( 1 ) {
           j = -1;
           for ( i = 0; i <= k; i++ ) {
               if ( !(gi = g->body[i]) ) continue;
               if ( j < 0 ) {
                   j = i;
                   gj = g->body[j];
                   sum = HCZ(gj);
               } else {
                   nv = NV(gi);
                   c = DL_COMPARE(HDL(gi),HDL(gj));
                   if ( c > 0 ) {
                       if ( sum ) HCZ(gj) = sum;
                       else g->body[j] = nd_remove_head(gj);
                       j = i;
                       gj = g->body[j];
                       sum = HCZ(gj);
                   } else if ( c == 0 ) {
                       addlf(sum,HCZ(gi),&t);
                       sum = t;
                       g->body[i] = nd_remove_head(gi);
                   }
               }
           }
           if ( j < 0 ) return -1;
           else if ( sum ) {
               HCZ(gj) = sum;
               return j;
           } else
               g->body[j] = nd_remove_head(gj);
       }
   }
   
 ND normalize_pbucket(int mod,PGeoBucket g)  ND normalize_pbucket(int mod,PGeoBucket g)
 {  {
     int i;      int i;
Line 2007  NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i
Line 2101  NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i
     while ( d ) {      while ( d ) {
 again:  again:
         l = nd_minp(d,&d);          l = nd_minp(d,&d);
           if ( MaxDeg > 0 && SG(l) > MaxDeg ) break;
         if ( SG(l) != sugar ) {          if ( SG(l) != sugar ) {
             if ( ishomo ) {              if ( ishomo ) {
                 diag_count = 0;                  diag_count = 0;
Line 2265  NODE nd_gb_trace(int m,int ishomo,int **indp)
Line 2360  NODE nd_gb_trace(int m,int ishomo,int **indp)
     while ( d ) {      while ( d ) {
 again:  again:
         l = nd_minp(d,&d);          l = nd_minp(d,&d);
           if ( MaxDeg > 0 && SG(l) > MaxDeg ) break;
         if ( SG(l) != sugar ) {          if ( SG(l) != sugar ) {
 #if 1  #if 1
             if ( ishomo ) {              if ( ishomo ) {
Line 2362  again:
Line 2458  again:
         FREENDP(l);          FREENDP(l);
     }      }
     if ( nd_nalg ) {      if ( nd_nalg ) {
         print_eg("monic",&eg_monic);          if ( DP_Print ) {
         print_eg("invdalg",&eg_invdalg);            print_eg("monic",&eg_monic);
         print_eg("le",&eg_le);            print_eg("invdalg",&eg_invdalg);
             print_eg("le",&eg_le);
           }
     }      }
         conv_ilist(nd_demand,1,g,indp);          conv_ilist(nd_demand,1,g,indp);
     if ( DP_Print ) { printf("nd_gb_trace done.\n"); fflush(stdout); }      if ( DP_Print ) { printf("nd_gb_trace done.\n"); fflush(stdout); }
Line 2530  ND_pairs nd_newpairs( NODE g, int t )
Line 2628  ND_pairs nd_newpairs( NODE g, int t )
         ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm);          ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm);
         s = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1]));          s = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1]));
         SG(r) = MAX(s,ts) + TD(LCM(r));          SG(r) = MAX(s,ts) + TD(LCM(r));
           /* experimental */
           if ( nd_sugarweight )
               r->sugar2 = ndl_weight2(r->lcm);
     }      }
     if ( r0 ) NEXT(r) = 0;      if ( r0 ) NEXT(r) = 0;
     return r0;      return r0;
 }  }
   
   /* ipair = [i1,i2],[i1,i2],... */
   ND_pairs nd_ipairtospair(NODE ipair)
   {
     int s1,s2;
     NODE tn,t;
     ND_pairs r,r0;
   
     for ( r0 = 0, t = ipair; t; t = NEXT(t) ) {
       NEXTND_pairs(r0,r);
       tn = BDY((LIST)BDY(t));
       r->i1 = QTOS((Q)ARG0(tn));
       r->i2 = QTOS((Q)ARG1(tn));
       ndl_lcm(DL(nd_psh[r->i1]),DL(nd_psh[r->i2]),r->lcm);
       s1 = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1]));
       s2 = SG(nd_psh[r->i2])-TD(DL(nd_psh[r->i2]));
       SG(r) = MAX(s1,s2) + TD(LCM(r));
       /* experimental */
       if ( nd_sugarweight )
           r->sugar2 = ndl_weight2(r->lcm);
     }
     if ( r0 ) NEXT(r) = 0;
     return r0;
   }
   
 /* kokokara */  /* kokokara */
   
 ND_pairs crit_B( ND_pairs d, int s )  ND_pairs crit_B( ND_pairs d, int s )
Line 2547  ND_pairs crit_B( ND_pairs d, int s )
Line 2672  ND_pairs crit_B( ND_pairs d, int s )
     t = DL(nd_psh[s]);      t = DL(nd_psh[s]);
     prev = 0;      prev = 0;
     head = cur = d;      head = cur = d;
     lcm = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      lcm = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     while ( cur ) {      while ( cur ) {
         tl = cur->lcm;          tl = cur->lcm;
         if ( ndl_reducible(tl,t) ) {          if ( ndl_reducible(tl,t) ) {
Line 2715  ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )
Line 2840  ND_pairs nd_minp( ND_pairs d, ND_pairs *prest )
         NEXT(m) = 0;          NEXT(m) = 0;
         return m;          return m;
     }      }
     s = SG(m);  
     if ( !NoSugar ) {      if ( !NoSugar ) {
         for ( ml = 0, l = m; p; p = NEXT(l = p) )          if ( nd_sugarweight ) {
             if ( (SG(p) < s)              s = m->sugar2;
                 || ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {              for ( ml = 0, l = m; p; p = NEXT(l = p) )
                 ml = l; m = p; s = SG(m);                  if ( (p->sugar2 < s)
             }                      || ((p->sugar2 == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {
                       ml = l; m = p; s = m->sugar2;
                   }
           } else {
               s = SG(m);
               for ( ml = 0, l = m; p; p = NEXT(l = p) )
                   if ( (SG(p) < s)
                       || ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) {
                       ml = l; m = p; s = SG(m);
                   }
           }
     } else {      } else {
         for ( ml = 0, l = m; p; p = NEXT(l = p) )          for ( ml = 0, l = m; p; p = NEXT(l = p) )
             if ( DL_COMPARE(LCM(p),LCM(m)) < 0 ) {              if ( DL_COMPARE(LCM(p),LCM(m)) < 0 ) {
Line 2742  ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )
Line 2876  ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )
     int msugar,i;      int msugar,i;
     ND_pairs t,dm0,dm,dr0,dr;      ND_pairs t,dm0,dm,dr0,dr;
   
     for ( msugar = SG(d), t = NEXT(d); t; t = NEXT(t) )      if ( nd_sugarweight ) {
         if ( SG(t) < msugar ) msugar = SG(t);          for ( msugar = d->sugar2, t = NEXT(d); t; t = NEXT(t) )
     dm0 = 0; dr0 = 0;              if ( t->sugar2 < msugar ) msugar = t->sugar2;
     for ( i = 0, t = d; t; t = NEXT(t) )          dm0 = 0; dr0 = 0;
         if ( i < nd_f4_nsp && SG(t) == msugar ) {          for ( i = 0, t = d; t; t = NEXT(t) )
             if ( dm0 ) NEXT(dm) = t;              if ( i < nd_f4_nsp && t->sugar2 == msugar ) {
             else dm0 = t;                  if ( dm0 ) NEXT(dm) = t;
             dm = t;                  else dm0 = t;
             i++;                  dm = t;
         } else {                  i++;
             if ( dr0 ) NEXT(dr) = t;              } else {
             else dr0 = t;                  if ( dr0 ) NEXT(dr) = t;
             dr = t;                  else dr0 = t;
         }                  dr = t;
               }
       } else {
           for ( msugar = SG(d), t = NEXT(d); t; t = NEXT(t) )
               if ( SG(t) < msugar ) msugar = SG(t);
           dm0 = 0; dr0 = 0;
           for ( i = 0, t = d; t; t = NEXT(t) )
               if ( i < nd_f4_nsp && SG(t) == msugar ) {
                   if ( dm0 ) NEXT(dm) = t;
                   else dm0 = t;
                   dm = t;
                   i++;
               } else {
                   if ( dr0 ) NEXT(dr) = t;
                   else dr0 = t;
                   dr = t;
               }
       }
     NEXT(dm) = 0;      NEXT(dm) = 0;
     if ( dr0 ) NEXT(dr) = 0;      if ( dr0 ) NEXT(dr) = 0;
     *prest = dr0;      *prest = dr0;
     return dm0;      return dm0;
 }  }
   
   int nd_tdeg(NDV c)
   {
     int wmax = 0;
     int i,len;
     NMV a;
   
     len = LEN(c);
     for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )
       wmax = MAX(TD(DL(a)),wmax);
     return wmax;
   }
   
 int ndv_newps(int m,NDV a,NDV aq,int f4)  int ndv_newps(int m,NDV a,NDV aq,int f4)
 {  {
     int len;      int len;
Line 2786  int ndv_newps(int m,NDV a,NDV aq,int f4)
Line 2949  int ndv_newps(int m,NDV a,NDV aq,int f4)
     nd_ps[nd_psn] = a;      nd_ps[nd_psn] = a;
     if ( aq ) {      if ( aq ) {
         nd_ps_trace[nd_psn] = aq;          nd_ps_trace[nd_psn] = aq;
                 if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq);          if ( !m ) {
         register_hcf(aq);                    if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq);
             register_hcf(aq);
           } else if ( m == -2 ) {
             /* do nothing */
           } else
             error("ndv_newps : invalud modulus");
         nd_bound[nd_psn] = ndv_compute_bound(aq);          nd_bound[nd_psn] = ndv_compute_bound(aq);
         SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r));  #if 1
           SG(r) = SG(aq);
   #else
           SG(r) = nd_tdeg(aq);
   #endif
           ndl_copy(HDL(aq),DL(r));
     } else {      } else {
         if ( !m ) register_hcf(a);          if ( !m ) register_hcf(a);
         nd_bound[nd_psn] = ndv_compute_bound(a);          nd_bound[nd_psn] = ndv_compute_bound(a);
         SG(r) = SG(a); ndl_copy(HDL(a),DL(r));  #if 1
           SG(r) = SG(a);
   #else
           SG(r) = nd_tdeg(a);
   #endif
           ndl_copy(HDL(a),DL(r));
                 if ( !m && !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(a);                  if ( !m && !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(a);
     }      }
     if ( nd_demand ) {      if ( nd_demand ) {
         if ( aq ) {          if ( aq ) {
             ndv_save(nd_ps_trace[nd_psn],nd_psn);              ndv_save(nd_ps_trace[nd_psn],nd_psn);
               nd_ps_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[nd_psn]);
             nd_ps_trace_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[nd_psn]);              nd_ps_trace_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[nd_psn]);
             nd_ps_trace[nd_psn] = 0;              nd_ps_trace[nd_psn] = 0;
         } else {          } else {
Line 2838  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
Line 3017  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
     nd_tracelist = 0;      nd_tracelist = 0;
   
     for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++;      for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++;
     w = (NDVI)ALLOCA(nd_psn*sizeof(struct oNDVI));      w = (NDVI)MALLOC(nd_psn*sizeof(struct oNDVI));
     for ( i = j = 0, s = f; s; s = NEXT(s), j++ )      for ( i = j = 0, s = f; s; s = NEXT(s), j++ )
         if ( BDY(s) ) { w[i].p = BDY(s); w[i].i = j; i++; }          if ( BDY(s) ) { w[i].p = BDY(s); w[i].i = j; i++; }
     if ( !dont_sort ) {      if ( !dont_sort ) {
Line 2871  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
Line 3050  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
     for ( i = 0; i < nd_psn; i++ ) {      for ( i = 0; i < nd_psn; i++ ) {
         hc = HCU(w[i].p);          hc = HCU(w[i].p);
         if ( trace ) {          if ( trace ) {
             a = nd_ps_trace[i] = ndv_dup(0,w[i].p);              if ( mod == -2 ) {
                         if ( !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);                /* over a large finite field */
             if ( !dont_removecont) ndv_removecont(0,a);                /* trace = small modulus */
             register_hcf(a);                a = nd_ps_trace[i] = ndv_dup(-2,w[i].p);
             am = nd_ps[i] = ndv_dup(mod,a);                ndv_mod(-2,a);
             ndv_mod(mod,am);                if ( !dont_removecont) ndv_removecont(-2,a);
                 if ( DL_COMPARE(HDL(am),HDL(a)) )                am = nd_ps[i] = ndv_dup(trace,w[i].p);
                     return 0;                ndv_mod(trace,am);
             ndv_removecont(mod,am);                    if ( DL_COMPARE(HDL(am),HDL(a)) )
                         return 0;
                 ndv_removecont(trace,am);
               } else {
                 a = nd_ps_trace[i] = ndv_dup(0,w[i].p);
                             if ( !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);
                 if ( !dont_removecont) ndv_removecont(0,a);
                 register_hcf(a);
                 am = nd_ps[i] = ndv_dup(mod,a);
                 ndv_mod(mod,am);
                     if ( DL_COMPARE(HDL(am),HDL(a)) )
                         return 0;
                 ndv_removecont(mod,am);
               }
         } else {          } else {
             a = nd_ps[i] = ndv_dup(mod,w[i].p);              a = nd_ps[i] = ndv_dup(mod,w[i].p);
                         if ( !mod && !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);                          if ( !mod && !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a);
Line 2898  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
Line 3090  int ndv_setup(int mod,int trace,NODE f,int dont_sort,i
         if ( nd_demand ) {          if ( nd_demand ) {
             if ( trace ) {              if ( trace ) {
                 ndv_save(nd_ps_trace[i],i);                  ndv_save(nd_ps_trace[i],i);
                   nd_ps_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);
                 nd_ps_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);                  nd_ps_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);
                 nd_ps_trace[i] = 0;                  nd_ps_trace[i] = 0;
             } else {              } else {
Line 2932  void preprocess_algcoef(VL vv,VL av,struct order_spec 
Line 3125  void preprocess_algcoef(VL vv,VL av,struct order_spec 
     LIST f1,f2;      LIST f1,f2;
     struct order_spec *current_spec;      struct order_spec *current_spec;
     VECT obj,obj0;      VECT obj,obj0;
     Obj tmp;      VECT tmp;
   
     for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++);      for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++);
     for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++);      for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++);
Line 2946  void preprocess_algcoef(VL vv,VL av,struct order_spec 
Line 3139  void preprocess_algcoef(VL vv,VL av,struct order_spec 
   
     /* simplification, making polynomials monic */      /* simplification, making polynomials monic */
     setfield_dalg(alist);      setfield_dalg(alist);
     obj_algtodalg(f,&f1);      obj_algtodalg((Obj)f,(Obj *)&f1);
     for ( t = BDY(f); t; t = NEXT(t) ) {      for ( t = BDY(f); t; t = NEXT(t) ) {
         initd(ord); ptod(vv,vv,(P)BDY(t),&d);          initd(ord); ptod(vv,vv,(P)BDY(t),&d);
         hc = (DAlg)BDY(d)->c;          hc = (DAlg)BDY(d)->c;
         if ( NID(hc) == N_DA ) {          if ( NID(hc) == N_DA ) {
             invdalg(hc,&inv);              invdalg(hc,&inv);
             for ( m = BDY(d); m; m = NEXT(m) ) {              for ( m = BDY(d); m; m = NEXT(m) ) {
                 muldalg(inv,(DAlg)m->c,&da); m->c = (P)da;                  muldalg(inv,(DAlg)m->c,&da); m->c = (Obj)da;
             }              }
         }          }
         initd(ord); dtop(vv,vv,d,&poly); BDY(f) = (pointer)poly;          initd(ord); dtop(vv,vv,d,(Obj *)&poly); BDY(f) = (pointer)poly;
     }      }
     obj_dalgtoalg(f1,&f);      obj_dalgtoalg((Obj)f1,(Obj *)&f);
   
     /* append alg vars to the var list */      /* append alg vars to the var list */
     for ( tv = vv; NEXT(tv); tv = NEXT(tv) );      for ( tv = vv; NEXT(tv); tv = NEXT(tv) );
Line 2975  void preprocess_algcoef(VL vv,VL av,struct order_spec 
Line 3168  void preprocess_algcoef(VL vv,VL av,struct order_spec 
     }      }
     MKLIST(f1,t);      MKLIST(f1,t);
     *alistp = alist;      *alistp = alist;
     algobjtorat(f1,f1p);      algobjtorat((Obj)f1,(Obj *)f1p);
   
     /* creating a new weight vector */      /* creating a new weight vector */
     prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj;      prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj;
Line 2996  NODE postprocess_algcoef(VL av,NODE alist,NODE r)
Line 3189  NODE postprocess_algcoef(VL av,NODE alist,NODE r)
     NODE s,t,u0,u;      NODE s,t,u0,u;
     P p;      P p;
     VL tv;      VL tv;
     Obj obj,tmp;      Obj obj;
       VECT tmp;
     NODE arg;      NODE arg;
   
     u0 = 0;      u0 = 0;
Line 3034  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
Line 3228  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
     NODE tr,tl1,tl2,tl3,tl4,nzlist;      NODE tr,tl1,tl2,tl3,tl4,nzlist;
     LIST l1,l2,l3,l4,l5;      LIST l1,l2,l3,l4,l5;
         int j;          int j;
         Q jq,bpe;          Q jq,bpe,last_nonzero;
     int *perm;      int *perm;
     EPOS oepos;      EPOS oepos;
     int obpe,oadv,ompos,cbpe;      int obpe,oadv,ompos,cbpe;
Line 3050  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
Line 3244  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
     ndv_alloc = 0;      ndv_alloc = 0;
 #endif  #endif
     get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);      get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);
       if ( m && nd_vc )
          error("nd_{gr,f4} : computation over Fp(X) is unsupported. Use dp_gr_mod_main().");
     for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );      for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
     switch ( ord->id ) {      switch ( ord->id ) {
         case 1:          case 1:
Line 3119  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
Line 3315  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
         }          }
         homogenize_order(ord,nvar,&ord1);          homogenize_order(ord,nvar,&ord1);
         nd_init_ord(ord1);          nd_init_ord(ord1);
         nd_setup_parameters(nvar+1,wmax);          nd_setup_parameters(nvar+1,nd_nzlist?0:wmax);
         for ( t = fd0; t; t = NEXT(t) )          for ( t = fd0; t; t = NEXT(t) )
             ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);              ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);
     }      }
Line 3142  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
Line 3338  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int 
         }          }
                 return;                  return;
         }          }
     x = f4?nd_f4(m,&perm):nd_gb(m,ishomo || homo,0,0,&perm);      x = f4?nd_f4(m,0,&perm):nd_gb(m,ishomo || homo,0,0,&perm);
         if ( !x ) {          if ( !x ) {
                 *rp = 0; return;                  *rp = 0; return;
         }          }
Line 3191  FINAL:
Line 3387  FINAL:
     if ( nd_gentrace ) {      if ( nd_gentrace ) {
         if ( f4 ) {          if ( f4 ) {
             STOQ(16,bpe);              STOQ(16,bpe);
             tr = mknode(4,*rp,(!ishomo&&homo)?ONE:0,BDY(nzlist),bpe); MKLIST(*rp,tr);              STOQ(nd_last_nonzero,last_nonzero);
               tr = mknode(5,*rp,(!ishomo&&homo)?ONE:0,BDY(nzlist),bpe,last_nonzero); MKLIST(*rp,tr);
   
         } else {          } else {
             tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);              tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);
             tl3 = reverse_node(tl3);              tl3 = reverse_node(tl3);
Line 3322  NDV recompute_trace(NODE ti,NDV *p,int mod)
Line 3520  NDV recompute_trace(NODE ti,NDV *p,int mod)
         static int afo=0;          static int afo=0;
   
         afo++;          afo++;
         mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));          mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));
         CM(mul) = 1;          CM(mul) = 1;
         tail = 0;          tail = 0;
         for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) {          for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) {
Line 3343  NDV recompute_trace(NODE ti,NDV *p,int mod)
Line 3541  NDV recompute_trace(NODE ti,NDV *p,int mod)
                                         }                                          }
                                 }                                  }
                                 if ( !m ) return 0; /* failure */                                  if ( !m ) return 0; /* failure */
                                 else {                  else {
                                         BDY(r) = m;                                          BDY(r) = m;
                                         c1 = invm(HCM(rm),mod); c2 = mod-HCM(r);                      if ( mod > 0 || mod == -1 ) {
                                         DMAR(c1,c2,0,mod,c);                                            c1 = invm(HCM(rm),mod); c2 = mod-HCM(r);
                                         nd_mul_c(mod,rm,c);                                            DMAR(c1,c2,0,mod,c);
                                             nd_mul_c(mod,rm,c);
                       } else {
                         GZ t,u;
   
                         chsgnlf(HCZ(r),&t);
                         divlf(t,HCZ(rm),&u);
                         nd_mul_c_lf(rm,u);
                       }
                                         r = nd_add(mod,r,rm);                                          r = nd_add(mod,r,rm);
                                 }                            }
                         }            }
                 }             }
         }          }
         if ( tail ) NEXT(tail) = 0;          if ( tail ) NEXT(tail) = 0;
         d = nd_add(mod,d,r);          d = nd_add(mod,d,r);
Line 3474  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3680  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     Q jq,bpe;      Q jq,bpe;
   
     nd_module = 0;      nd_module = 0;
       nd_lf = 0;
     parse_nd_option(current_option);      parse_nd_option(current_option);
       if ( nd_lf ) {
         if ( f4 )
           nd_f4_lf_trace(f,v,trace,homo,ord,rp);
         else
           error("nd_gr_trace is not implemented yet over a large finite field");
         return;
       }
     if ( DP_Multiple )      if ( DP_Multiple )
         nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);          nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);
   
Line 3564  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3778  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
         for ( t = fd0; t; t = NEXT(t) )          for ( t = fd0; t; t = NEXT(t) )
             ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);              ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);
     }      }
       if ( MaxDeg > 0 ) nocheck = 1;
     while ( 1 ) {      while ( 1 ) {
                 tl1 = tl2 = tl3 = tl4 = 0;                  tl1 = tl2 = tl3 = tl4 = 0;
         if ( Demand )          if ( Demand )
Line 3600  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3815  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
                             tl3 = nd_alltracelist; nd_alltracelist = 0;                              tl3 = nd_alltracelist; nd_alltracelist = 0;
                     } else tl3 = 0;                      } else tl3 = 0;
             /* gbcheck : cand is a GB of Id(cand) ? */              /* gbcheck : cand is a GB of Id(cand) ? */
             ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0;              if ( nd_vc || nd_gentrace || nd_gensyz )
                 ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0;
               else
                 ret = nd_f4(0,1,0)!=0;
             if ( nd_gentrace && nd_gensyz ) {              if ( nd_gentrace && nd_gensyz ) {
                             tl4 = nd_alltracelist; nd_alltracelist = 0;                              tl4 = nd_alltracelist; nd_alltracelist = 0;
                     } else tl4 = 0;                      } else tl4 = 0;
Line 3624  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3842  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     }      }
     get_eg(&eg1); init_eg(&eg_check); add_eg(&eg_check,&eg0,&eg1);      get_eg(&eg1); init_eg(&eg_check); add_eg(&eg_check,&eg0,&eg1);
     if ( DP_Print )      if ( DP_Print )
         fprintf(asir_out,"check=%fsec\n",eg_check.exectime+eg_check.gctime);          fprintf(asir_out,"check=%.3fsec,",eg_check.exectime+eg_check.gctime);
     /* dp->p */      /* dp->p */
     nd_bpe = cbpe;      nd_bpe = cbpe;
     nd_setup_parameters(nd_nvar,0);      nd_setup_parameters(nd_nvar,0);
Line 3713  void nmtodp(int mod,NM m,DP *r)
Line 3931  void nmtodp(int mod,NM m,DP *r)
   
     NEWMP(mr);      NEWMP(mr);
     mr->dl = ndltodl(nd_nvar,DL(m));      mr->dl = ndltodl(nd_nvar,DL(m));
     mr->c = ndctop(mod,m->c);      mr->c = (Obj)ndctop(mod,m->c);
     NEXT(mr) = 0; MKDP(nd_nvar,mr,dp); dp->sugar = mr->dl->td;      NEXT(mr) = 0; MKDP(nd_nvar,mr,dp); dp->sugar = mr->dl->td;
     *r = dp;      *r = dp;
 }  }
Line 3738  void ndl_print(UINT *dl)
Line 3956  void ndl_print(UINT *dl)
         for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i));          for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i));
     }      }
     printf(">>");      printf(">>");
     if ( MPOS(dl) )      if ( nd_module && MPOS(dl) )
         printf("*e%d",MPOS(dl));          printf("*e%d",MPOS(dl));
 }  }
   
Line 3793  void nd_removecont(int mod,ND p)
Line 4011  void nd_removecont(int mod,ND p)
     N q,r;      N q,r;
   
     if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p)));      if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p)));
     else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod));      else if ( mod == -2 ) {
         GZ inv;
         divlf(ONEGZ,HCZ(p),&inv);
         nd_mul_c_lf(p,inv);
       } else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod));
     else {      else {
         for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );          for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );
         w = (Q *)ALLOCA(n*sizeof(Q));          w = (Q *)MALLOC(n*sizeof(Q));
         v.len = n;          v.len = n;
         v.body = (pointer *)w;          v.body = (pointer *)w;
         for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m);          for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m);
Line 3817  void nd_removecont2(ND p1,ND p2)
Line 4039  void nd_removecont2(ND p1,ND p2)
     n1 = nd_length(p1);      n1 = nd_length(p1);
     n2 = nd_length(p2);      n2 = nd_length(p2);
     n = n1+n2;      n = n1+n2;
     w = (Q *)ALLOCA(n*sizeof(Q));      w = (Q *)MALLOC(n*sizeof(Q));
     v.len = n;      v.len = n;
     v.body = (pointer *)w;      v.body = (pointer *)w;
     i = 0;      i = 0;
Line 3844  void ndv_removecont(int mod,NDV p)
Line 4066  void ndv_removecont(int mod,NDV p)
   
     if ( mod == -1 )      if ( mod == -1 )
         ndv_mul_c(mod,p,_invsf(HCM(p)));          ndv_mul_c(mod,p,_invsf(HCM(p)));
     else if ( mod )      else if ( mod == -2 ) {
         GZ inv;
         divlf(ONEGZ,HCZ(p),&inv);
         ndv_mul_c_lf(p,inv);
       } else if ( mod )
         ndv_mul_c(mod,p,invm(HCM(p),mod));          ndv_mul_c(mod,p,invm(HCM(p),mod));
     else {      else {
         len = p->len;          len = p->len;
         w = (P *)ALLOCA(len*sizeof(P));          w = (P *)MALLOC(len*sizeof(P));
         c = (Q *)ALLOCA(len*sizeof(Q));          c = (Q *)MALLOC(len*sizeof(Q));
         for ( m = BDY(p), all_p = 1, i = 0; i < len; NMV_ADV(m), i++ ) {          for ( m = BDY(p), all_p = 1, i = 0; i < len; NMV_ADV(m), i++ ) {
             ptozp(CP(m),1,&c[i],&w[i]);              ptozp(CP(m),1,&c[i],&w[i]);
             all_p = all_p && !NUM(w[i]);              all_p = all_p && !NUM(w[i]);
Line 3883  void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos
Line 4109  void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos
     mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);      mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);
     m = (NMV)((char *)mr0+(len-1)*oadv);      m = (NMV)((char *)mr0+(len-1)*oadv);
     mr = (NMV)((char *)mr0+(len-1)*nmv_adv);      mr = (NMV)((char *)mr0+(len-1)*nmv_adv);
     t = (NMV)ALLOCA(nmv_adv);      t = (NMV)MALLOC(nmv_adv);
     for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {      for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {
         ndl_homogenize(DL(m),DL(t),obpe,oepos,ompos,max);          ndl_homogenize(DL(m),DL(t),obpe,oepos,ompos,max);
         CQ(mr) = CQ(m);          CQ(mr) = CQ(m);
Line 3931  void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr
Line 4157  void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr
     NODE l;      NODE l;
     P h,gcd,t;      P h,gcd,t;
   
     tpl = (P *)ALLOCA(m*sizeof(P));      tpl = (P *)MALLOC(m*sizeof(P));
     tpl1 = (P *)ALLOCA(m*sizeof(P));      tpl1 = (P *)MALLOC(m*sizeof(P));
     bcopy(pl,tpl,m*sizeof(P));      bcopy(pl,tpl,m*sizeof(P));
     gcd = (P)ONE;      gcd = (P)ONE;
     for ( l = nd_hcf; l; l = NEXT(l) ) {      for ( l = nd_hcf; l; l = NEXT(l) ) {
Line 3968  void removecont_array(P *p,int n,int full)
Line 4194  void removecont_array(P *p,int n,int full)
     if ( all_q ) {      if ( all_q ) {
         removecont_array_q((Q *)p,n);          removecont_array_q((Q *)p,n);
     } else {      } else {
         c = (Q *)ALLOCA(n*sizeof(Q));          c = (Q *)MALLOC(n*sizeof(Q));
         w = (P *)ALLOCA(n*sizeof(P));          w = (P *)MALLOC(n*sizeof(P));
         for ( i = 0; i < n; i++ ) {          for ( i = 0; i < n; i++ ) {
             ptozp(p[i],1,&c[i],&w[i]);              ptozp(p[i],1,&c[i],&w[i]);
         }          }
Line 3989  void removecont_array_q(Q *c,int n)
Line 4215  void removecont_array_q(Q *c,int n)
     N qn,rn,gn;      N qn,rn,gn;
     Q *q,*r;      Q *q,*r;
   
     q = (Q *)ALLOCA(n*sizeof(Q));      q = (Q *)MALLOC(n*sizeof(Q));
     r = (Q *)ALLOCA(n*sizeof(Q));      r = (Q *)MALLOC(n*sizeof(Q));
     v.id = O_VECT; v.len = n; v.body = (pointer *)c;      v.id = O_VECT; v.len = n; v.body = (pointer *)c;
     igcdv_estimate(&v,&d0);      igcdv_estimate(&v,&d0);
     for ( i = 0; i < n; i++ ) {      for ( i = 0; i < n; i++ ) {
Line 4032  void nd_mul_c(int mod,ND p,int mul)
Line 4258  void nd_mul_c(int mod,ND p,int mul)
         }          }
 }  }
   
   void nd_mul_c_lf(ND p,GZ mul)
   {
       NM m;
       GZ c;
   
       if ( !p ) return;
       if ( UNIGZ(mul) ) return;
       for ( m = BDY(p); m; m = NEXT(m) ) {
           mullf(CZ(m),mul,&c); CZ(m) = c;
       }
   }
   
 void nd_mul_c_q(ND p,P mul)  void nd_mul_c_q(ND p,P mul)
 {  {
     NM m;      NM m;
Line 4096  UINT *ndv_compute_bound(NDV p)
Line 4334  UINT *ndv_compute_bound(NDV p)
   
     if ( !p )      if ( !p )
         return 0;          return 0;
     d1 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     d2 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     len = LEN(p);      len = LEN(p);
     m = BDY(p); ndl_copy(DL(m),d1); NMV_ADV(m);      m = BDY(p); ndl_copy(DL(m),d1); NMV_ADV(m);
     for ( i = 1; i < len; i++, NMV_ADV(m) ) {      for ( i = 1; i < len; i++, NMV_ADV(m) ) {
Line 4125  UINT *nd_compute_bound(ND p)
Line 4363  UINT *nd_compute_bound(ND p)
   
     if ( !p )      if ( !p )
         return 0;          return 0;
     d1 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     d2 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     len = LEN(p);      len = LEN(p);
     m = BDY(p); ndl_copy(DL(m),d1); m = NEXT(m);      m = BDY(p); ndl_copy(DL(m),d1); m = NEXT(m);
     for ( m = NEXT(m); m; m = NEXT(m) ) {      for ( m = NEXT(m); m; m = NEXT(m) ) {
Line 4159  int nd_get_exporigin(struct order_spec *ord)
Line 4397  int nd_get_exporigin(struct order_spec *ord)
             /* module d[0]:weight d[1]:w0,...,d[nd_exporigin-2]:w(n-1) */              /* module d[0]:weight d[1]:w0,...,d[nd_exporigin-2]:w(n-1) */
             return ord->ord.block.length+1+nd_module;              return ord->ord.block.length+1+nd_module;
         case 3: case 259:          case 3: case 259:
   #if 0
             error("nd_get_exporigin : composite order is not supported yet.");              error("nd_get_exporigin : composite order is not supported yet.");
   #else
               return 1+nd_module;
   #endif
     }      }
 }  }
   
Line 4285  ND_pairs nd_reconstruct(int trace,ND_pairs d)
Line 4527  ND_pairs nd_reconstruct(int trace,ND_pairs d)
         ndl_reconstruct(LCM(t),LCM(s),obpe,oepos);          ndl_reconstruct(LCM(t),LCM(s),obpe,oepos);
     }      }
   
     old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist));      old_red = (RHist *)MALLOC(REDTAB_LEN*sizeof(RHist));
     for ( i = 0; i < REDTAB_LEN; i++ ) {      for ( i = 0; i < REDTAB_LEN; i++ ) {
         old_red[i] = nd_red[i];          old_red[i] = nd_red[i];
         nd_red[i] = 0;          nd_red[i] = 0;
Line 4402  int nd_sp(int mod,int trace,ND_pairs p,ND *rp)
Line 4644  int nd_sp(int mod,int trace,ND_pairs p,ND *rp)
   
     if ( mod == -1 ) {      if ( mod == -1 ) {
         CM(m1) = HCM(p2); CM(m2) = _chsgnsf(HCM(p1));          CM(m1) = HCM(p2); CM(m2) = _chsgnsf(HCM(p1));
     } else if ( mod ) {      } else if ( mod > 0 ) {
         CM(m1) = HCM(p2); CM(m2) = mod-HCM(p1);          CM(m1) = HCM(p2); CM(m2) = mod-HCM(p1);
       } else if ( mod == -2 ) {
           CZ(m1) = HCZ(p2); chsgnlf(HCZ(p1),&CZ(m2));
     } else if ( nd_vc ) {      } else if ( nd_vc ) {
         ezgcdpz(nd_vc,HCP(p1),HCP(p2),&gp);          ezgcdpz(nd_vc,HCP(p1),HCP(p2),&gp);
         divsp(nd_vc,HCP(p2),gp,&CP(m1));          divsp(nd_vc,HCP(p2),gp,&CP(m1));
Line 4441  void ndv_mul_c(int mod,NDV p,int mul)
Line 4685  void ndv_mul_c(int mod,NDV p,int mul)
         }          }
 }  }
   
   void ndv_mul_c_lf(NDV p,GZ mul)
   {
       NMV m;
       GZ c;
       int len,i;
   
       if ( !p ) return;
       len = LEN(p);
       for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {
           mullf(CZ(m),mul,&c); CZ(m) = c;
       }
   }
   
 void ndv_mul_c_q(NDV p,Q mul)  void ndv_mul_c_q(NDV p,Q mul)
 {  {
     NMV m;      NMV m;
Line 4467  ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) {
Line 4724  ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) {
     d0 = DL(m0);      d0 = DL(m0);
     l = LEN(p);      l = LEN(p);
     for ( i = 0, tlen = 1; i < n2; i++ ) tlen *= (GET_EXP(d0,n2+i)+1);      for ( i = 0, tlen = 1; i < n2; i++ ) tlen *= (GET_EXP(d0,n2+i)+1);
     tab = (NM *)ALLOCA(tlen*sizeof(NM));      tab = (NM *)MALLOC(tlen*sizeof(NM));
     psum = (NM *)ALLOCA(tlen*sizeof(NM));      psum = (NM *)MALLOC(tlen*sizeof(NM));
     for ( i = 0; i < tlen; i++ ) psum[i] = 0;      for ( i = 0; i < tlen; i++ ) psum[i] = 0;
     m1 = (NMV)(((char *)BDY(p))+nmv_adv*(l-1));      m1 = (NMV)(((char *)BDY(p))+nmv_adv*(l-1));
     for ( i = l-1; i >= 0; i--, NMV_PREV(m1) ) {      for ( i = l-1; i >= 0; i--, NMV_PREV(m1) ) {
Line 4546  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4803  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
         }          }
         min = MIN(k,l);          min = MIN(k,l);
         if ( mod ) {          if ( mod ) {
             ctab = (UINT *)ALLOCA((min+1)*sizeof(UINT));              ctab = (UINT *)MALLOC((min+1)*sizeof(UINT));
             mkwcm(k,l,mod,ctab);              mkwcm(k,l,mod,ctab);
         } else {          } else {
             ctab_q = (Q *)ALLOCA((min+1)*sizeof(Q));              ctab_q = (Q *)MALLOC((min+1)*sizeof(Q));
             mkwc(k,l,ctab_q);              mkwc(k,l,ctab_q);
         }          }
         for ( j = min; j >= 0; j-- ) {          for ( j = min; j >= 0; j-- ) {
Line 4647  ND ndv_mul_nm(int mod,NM m0,NDV p)
Line 4904  ND ndv_mul_nm(int mod,NM m0,NDV p)
   
     if ( !p ) return 0;      if ( !p ) return 0;
     else if ( do_weyl )      else if ( do_weyl )
         if ( mod == -1 )          if ( mod < 0 )
             error("ndv_mul_nm : not implemented (weyl)");              error("ndv_mul_nm : not implemented (weyl)");
         else          else
             return weyl_ndv_mul_nm(mod,m0,p);              return weyl_ndv_mul_nm(mod,m0,p);
Line 4664  ND ndv_mul_nm(int mod,NM m0,NDV p)
Line 4921  ND ndv_mul_nm(int mod,NM m0,NDV p)
                 CM(mr) = _mulsf(CM(m),c);                  CM(mr) = _mulsf(CM(m),c);
                 ndl_add(DL(m),d,DL(mr));                  ndl_add(DL(m),d,DL(mr));
             }              }
           } else if ( mod == -2 ) {
               GZ cl;
               cl = CZ(m0);
               for ( i = 0; i < len; i++, NMV_ADV(m) ) {
                   NEXTNM(mr0,mr);
                   mullf(CZ(m),cl,&CZ(mr));
                   ndl_add(DL(m),d,DL(mr));
               }
         } else if ( mod ) {          } else if ( mod ) {
             c = CM(m0);              c = CM(m0);
             for ( i = 0; i < len; i++, NMV_ADV(m) ) {              for ( i = 0; i < len; i++, NMV_ADV(m) ) {
Line 4701  ND nd_quo(int mod,PGeoBucket bucket,NDV d)
Line 4966  ND nd_quo(int mod,PGeoBucket bucket,NDV d)
     else {      else {
         nv = NV(d);          nv = NV(d);
         mq0 = 0;          mq0 = 0;
         tm = (NMV)ALLOCA(nmv_adv);          tm = (NMV)MALLOC(nmv_adv);
         while ( 1 ) {          while ( 1 ) {
             hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket);              if ( mod > 0 || mod == -1 )
                 hindex = head_pbucket(mod,bucket);
               else if ( mod == -2 )
                 hindex = head_pbucket_lf(bucket);
               else
                 hindex = head_pbucket_q(bucket);
             if ( hindex < 0 ) break;              if ( hindex < 0 ) break;
             p = bucket->body[hindex];              p = bucket->body[hindex];
             NEXTNM(mq0,mq);              NEXTNM(mq0,mq);
Line 4746  void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)
Line 5016  void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos)
     mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);      mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p);
     m = (NMV)((char *)mr0+(len-1)*oadv);      m = (NMV)((char *)mr0+(len-1)*oadv);
     mr = (NMV)((char *)mr0+(len-1)*nmv_adv);      mr = (NMV)((char *)mr0+(len-1)*nmv_adv);
     t = (NMV)ALLOCA(nmv_adv);      t = (NMV)MALLOC(nmv_adv);
     for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {      for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) {
         CQ(t) = CQ(m);          CQ(t) = CQ(m);
         for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0;          for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0;
Line 4786  NDV ndv_dup(int mod,NDV p)
Line 5056  NDV ndv_dup(int mod,NDV p)
   
     if ( !p ) return 0;      if ( !p ) return 0;
     len = LEN(p);      len = LEN(p);
     m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));      m0 = m = (NMV)((mod>0 || mod==-1)?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));
     for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) {      for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) {
         ndl_copy(DL(t),DL(m));          ndl_copy(DL(t),DL(m));
         CQ(m) = CQ(t);          CQ(m) = CQ(t);
Line 4828  NDV ndv_symbolic(int mod,NDV p)
Line 5098  NDV ndv_symbolic(int mod,NDV p)
   
     if ( !p ) return 0;      if ( !p ) return 0;
     len = LEN(p);      len = LEN(p);
     m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));      m0 = m = (NMV)((mod>0||mod==-1)?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));
     for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) {      for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) {
         ndl_copy(DL(t),DL(m));          ndl_copy(DL(t),DL(m));
         CQ(m) = ONE;          CQ(m) = ONE;
Line 4894  void ndv_mod(int mod,NDV p)
Line 5164  void ndv_mod(int mod,NDV p)
     if ( mod == -1 )      if ( mod == -1 )
         for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {          for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {
             simp_ff((Obj)CP(t),&gfs);              simp_ff((Obj)CP(t),&gfs);
             r = FTOIF(CONT((GFS)gfs));              if ( gfs ) {
             CM(d) = r;                r = FTOIF(CONT((GFS)gfs));
             ndl_copy(DL(t),DL(d));                CM(d) = r;
             NMV_ADV(d);                ndl_copy(DL(t),DL(d));
             dlen++;                NMV_ADV(d);
                 dlen++;
               }
         }          }
       else if ( mod == -2 )
           for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {
               simp_ff((Obj)CP(t),&gfs);
               if ( gfs ) {
                 lmtolf(gfs,&CZ(d));
                 ndl_copy(DL(t),DL(d));
                 NMV_ADV(d);
                 dlen++;
               }
           }
     else      else
         for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {          for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) {
             if ( nd_vc ) {              if ( nd_vc ) {
Line 4947  void pltozpl(LIST l,Q *cont,LIST *pp)
Line 5229  void pltozpl(LIST l,Q *cont,LIST *pp)
     LIST r;      LIST r;
   
     nd = BDY(l); n = length(nd);      nd = BDY(l); n = length(nd);
     pl = (P *)ALLOCA(n*sizeof(P));      pl = (P *)MALLOC(n*sizeof(P));
     cl = (Q *)ALLOCA(n*sizeof(P));      cl = (Q *)MALLOC(n*sizeof(P));
     for ( i = 0; i < n; i++, nd = NEXT(nd) )      for ( i = 0; i < n; i++, nd = NEXT(nd) )
         ptozp((P)BDY(nd),1,&cl[i],&dmy);          ptozp((P)BDY(nd),1,&cl[i],&dmy);
     qltozl(cl,n,&dvr);      qltozl(cl,n,&dvr);
Line 5013  ND ptond(VL vl,VL dvl,P p)
Line 5295  ND ptond(VL vl,VL dvl,P p)
         return r;          return r;
     } else {      } else {
         for ( dc = DC(p), k = 0; dc; dc = NEXT(dc), k++ );          for ( dc = DC(p), k = 0; dc; dc = NEXT(dc), k++ );
         w = (DCP *)ALLOCA(k*sizeof(DCP));          w = (DCP *)MALLOC(k*sizeof(DCP));
         for ( dc = DC(p), j = 0; j < k; dc = NEXT(dc), j++ ) w[j] = dc;          for ( dc = DC(p), j = 0; j < k; dc = NEXT(dc), j++ ) w[j] = dc;
         for ( i = 0, tvl = dvl, v = VR(p);          for ( i = 0, tvl = dvl, v = VR(p);
             tvl && tvl->v != v; tvl = NEXT(tvl), i++ );              tvl && tvl->v != v; tvl = NEXT(tvl), i++ );
Line 5061  P ndvtop(int mod,VL vl,VL dvl,NDV p)
Line 5343  P ndvtop(int mod,VL vl,VL dvl,NDV p)
         m = (NMV)(((char *)BDY(p))+nmv_adv*(len-1));          m = (NMV)(((char *)BDY(p))+nmv_adv*(len-1));
         for ( j = len-1, s = 0; j >= 0; j--, NMV_PREV(m) ) {          for ( j = len-1, s = 0; j >= 0; j--, NMV_PREV(m) ) {
             if ( mod == -1 ) {              if ( mod == -1 ) {
                 e = IFTOF(CM(m)); MKGFS(e,gfs); c = (P)gfs;                 e = IFTOF(CM(m)); MKGFS(e,gfs); c = (P)gfs;
             } else if ( mod ) {              } else if ( mod == -2 ) {
                  c = (P)gztoz(CZ(m));
               } else if ( mod > 0 ) {
                 STOQ(CM(m),q); c = (P)q;                  STOQ(CM(m),q); c = (P)q;
             } else              } else
                 c = CP(m);                  c = CP(m);
Line 5093  LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank)
Line 5377  LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank)
   
     if ( !p ) return 0;      if ( !p ) return 0;
     else {      else {
         a = (P *)ALLOCA((rank+1)*sizeof(P));          a = (P *)MALLOC((rank+1)*sizeof(P));
         for ( i = 0; i <= rank; i++ ) a[i] = 0;          for ( i = 0; i <= rank; i++ ) a[i] = 0;
         len = LEN(p);          len = LEN(p);
         n = NV(p);          n = NV(p);
Line 5130  NDV ndtondv(int mod,ND p)
Line 5414  NDV ndtondv(int mod,ND p)
   
     if ( !p ) return 0;      if ( !p ) return 0;
     len = LEN(p);      len = LEN(p);
     if ( mod )      if ( mod > 0 || mod == -1 )
         m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(len*nmv_adv);          m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(len*nmv_adv);
     else      else
         m0 = m = MALLOC(len*nmv_adv);          m0 = m = MALLOC(len*nmv_adv);
Line 5180  DP ndvtodp(int mod,NDV p)
Line 5464  DP ndvtodp(int mod,NDV p)
     for ( t = BDY(p), i = 0; i < len; NMV_ADV(t), i++ ) {      for ( t = BDY(p), i = 0; i < len; NMV_ADV(t), i++ ) {
         NEXTMP(m0,m);          NEXTMP(m0,m);
         m->dl = ndltodl(nd_nvar,DL(t));          m->dl = ndltodl(nd_nvar,DL(t));
         m->c = ndctop(mod,t->c);          m->c = (Obj)ndctop(mod,t->c);
     }      }
     NEXT(m) = 0;      NEXT(m) = 0;
         MKDP(nd_nvar,m0,d);          MKDP(nd_nvar,m0,d);
Line 5201  DP ndtodp(int mod,ND p)
Line 5485  DP ndtodp(int mod,ND p)
     for ( t = BDY(p); t; t = NEXT(t) ) {      for ( t = BDY(p); t; t = NEXT(t) ) {
         NEXTMP(m0,m);          NEXTMP(m0,m);
         m->dl = ndltodl(nd_nvar,DL(t));          m->dl = ndltodl(nd_nvar,DL(t));
         m->c = ndctop(mod,t->c);          m->c = (Obj)ndctop(mod,t->c);
     }      }
     NEXT(m) = 0;      NEXT(m) = 0;
         MKDP(nd_nvar,m0,d);          MKDP(nd_nvar,m0,d);
Line 5251  NODE ndv_reducebase(NODE x,int *perm)
Line 5535  NODE ndv_reducebase(NODE x,int *perm)
     NODE t,t0;      NODE t,t0;
   
     len = length(x);      len = length(x);
     w = (NDVI)ALLOCA(len*sizeof(struct oNDVI));      w = (NDVI)MALLOC(len*sizeof(struct oNDVI));
     for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) {      for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) {
         w[i].p = BDY(t); w[i].i = perm[i];          w[i].p = BDY(t); w[i].i = perm[i];
     }      }
Line 5540  int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)
Line 5824  int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)
     return i;      return i;
 }  }
   
   #if defined(__GNUC__) && SIZEOF_LONG==8
   
   #define MOD128(a,c,m) ((a)=(((c)!=0||((a)>=(m)))?(((((U128)(c))<<64)+(a))%(m)):(a)))
   
   int nd_to_vect64(int mod,UINT *s0,int n,ND d,U64 *r)
   {
       NM m;
       UINT *t,*s;
       int i;
   
       for ( i = 0; i < n; i++ ) r[i] = 0;
       for ( i = 0, s = s0, m = BDY(d); m; m = NEXT(m) ) {
           t = DL(m);
           for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );
           r[i] = (U64)CM(m);
       }
       for ( i = 0; !r[i]; i++ );
       return i;
   }
   #endif
   
 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)  int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)
 {  {
     NM m;      NM m;
Line 5556  int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)
Line 5861  int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)
     return i;      return i;
 }  }
   
   int nd_to_vect_lf(UINT *s0,int n,ND d,mpz_t *r)
   {
       NM m;
       UINT *t,*s;
       int i;
   
       for ( i = 0; i < n; i++ ) { mpz_init(r[i]); mpz_set_ui(r[i],0); }
       for ( i = 0, s = s0, m = BDY(d); m; m = NEXT(m) ) {
           t = DL(m);
           for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );
           mpz_set(r[i],BDY(CZ(m)));
       }
       for ( i = 0; !mpz_sgn(r[i]); i++ );
       return i;
   }
   
 unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash,ND p)  unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash,ND p)
 {  {
     NM m;      NM m;
Line 5583  int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,N
Line 5904  int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,N
   
     d = DL(m);      d = DL(m);
     len = LEN(p);      len = LEN(p);
     t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      t = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {      for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {
         ndl_add(d,DL(mr),t);          ndl_add(d,DL(mr),t);
                 h = ndl_hash_value(t);                  h = ndl_hash_value(t);
Line 5608  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p
Line 5929  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p
     p = nd_ps[pair->index];      p = nd_ps[pair->index];
     len = LEN(p);      len = LEN(p);
     r = (Q *)CALLOC(n,sizeof(Q));      r = (Q *)CALLOC(n,sizeof(Q));
     t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      t = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {      for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {
         ndl_add(d,DL(mr),t);          ndl_add(d,DL(mr),t);
         for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );          for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );
Line 5617  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p
Line 5938  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p
     return r;      return r;
 }  }
   
 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,int *s0hash,NM_ind_pair pair)  IndArray nm_ind_pair_to_vect_compress(int trace,UINT *s0,int n,int *s0hash,NM_ind_pair pair)
 {  {
     NM m;      NM m;
     NMV mr;      NMV mr;
Line 5632  struct oEGT eg0,eg1;
Line 5953  struct oEGT eg0,eg1;
   
     m = pair->mul;      m = pair->mul;
     d = DL(m);      d = DL(m);
     p = nd_demand?nd_ps_sym[pair->index]:nd_ps[pair->index];      if ( trace )
         p = nd_demand?nd_ps_trace_sym[pair->index]:nd_ps_trace[pair->index];
       else
         p = nd_demand?nd_ps_sym[pair->index]:nd_ps[pair->index];
   
     len = LEN(p);      len = LEN(p);
     t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));      t = (UINT *)MALLOC(nd_wpd*sizeof(UINT));
     v = (unsigned int *)ALLOCA(len*sizeof(unsigned int));      v = (unsigned int *)MALLOC(len*sizeof(unsigned int));
 get_eg(&eg0);  get_eg(&eg0);
     for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {      for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {
         ndl_add(d,DL(mr),t);          ndl_add(d,DL(mr),t);
Line 5705  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
Line 6030  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
     for ( i = 0; i < col && !svect[i]; i++ );      for ( i = 0; i < col && !svect[i]; i++ );
     if ( i == col ) return maxrs;      if ( i == col ) return maxrs;
     hmag = p_mag((P)svect[i])*nd_scale;      hmag = p_mag((P)svect[i])*nd_scale;
     cvect = (Q *)ALLOCA(col*sizeof(Q));      cvect = (Q *)MALLOC(col*sizeof(Q));
     for ( i = 0; i < nred; i++ ) {      for ( i = 0; i < nred; i++ ) {
         ivect = imat[i];          ivect = imat[i];
         k = ivect->head;          k = ivect->head;
Line 5845  int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind
Line 6170  int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,Ind
     return maxrs;      return maxrs;
 }  }
   
   
 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)  int ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)
 {  {
     int i,j,k,len,pos,prev;      int i,j,k,len,pos,prev;
Line 5915  int ndv_reduce_vect(int m,UINT *svect,int col,IndArray
Line 6239  int ndv_reduce_vect(int m,UINT *svect,int col,IndArray
     return maxrs;      return maxrs;
 }  }
   
   #if defined(__GNUC__) && SIZEOF_LONG==8
   
   int ndv_reduce_vect64(int m,U64 *svect,U64 *cvect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)
   {
       int i,j,k,len,pos,prev;
       U64 a,c,c1,c2;
       IndArray ivect;
       unsigned char *ivc;
       unsigned short *ivs;
       unsigned int *ivi;
       NDV redv;
       NMV mr;
       NODE rp;
       int maxrs;
   
       for ( i = 0; i < col; i++ ) cvect[i] = 0;
       maxrs = 0;
       for ( i = 0; i < nred; i++ ) {
           ivect = imat[i];
           k = ivect->head;
           a = svect[k]; c = cvect[k];
           MOD128(a,c,m);
           svect[k] = a; cvect[k] = 0;
           if ( c = svect[k] ) {
               maxrs = MAX(maxrs,rp0[i]->sugar);
               c = m-c; redv = nd_ps[rp0[i]->index];
               len = LEN(redv); mr = BDY(redv);
               svect[k] = 0; prev = k;
               switch ( ivect->width ) {
                   case 1:
                       ivc = ivect->index.c;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivc[j]; c1 = CM(mr); prev = pos;
                           if ( c1 ) {
                             c2 = svect[pos]+c1*c;
                             if ( c2 < svect[pos] ) cvect[pos]++;
                             svect[pos] = c2;
                           }
                       }
                       break;
                   case 2:
                       ivs = ivect->index.s;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivs[j]; c1 = CM(mr); prev = pos;
                           if ( c1 ) {
                             c2 = svect[pos]+c1*c;
                             if ( c2 < svect[pos] ) cvect[pos]++;
                             svect[pos] = c2;
                           }
                       }
                       break;
                   case 4:
                       ivi = ivect->index.i;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivi[j]; c1 = CM(mr); prev = pos;
                           if ( c1 ) {
                             c2 = svect[pos]+c1*c;
                             if ( c2 < svect[pos] ) cvect[pos]++;
                             svect[pos] = c2;
                           }
                       }
                       break;
               }
           }
       }
       for ( i = 0; i < col; i++ ) {
         a = svect[i]; c = cvect[i]; MOD128(a,c,m); svect[i] = a;
       }
       return maxrs;
   }
   #endif
   
 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)  int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)
 {  {
     int i,j,k,len,pos,prev;      int i,j,k,len,pos,prev;
Line 5931  int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr
Line 6327  int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr
     maxrs = 0;      maxrs = 0;
     for ( i = 0; i < nred; i++ ) {      for ( i = 0; i < nred; i++ ) {
         ivect = imat[i];          ivect = imat[i];
         k = ivect->head; svect[k] %= m;          k = ivect->head;
         if ( c = svect[k] ) {          if ( c = svect[k] ) {
             maxrs = MAX(maxrs,rp0[i]->sugar);              maxrs = MAX(maxrs,rp0[i]->sugar);
             c = _chsgnsf(c); redv = nd_ps[rp0[i]->index];              c = _chsgnsf(c); redv = nd_ps[rp0[i]->index];
Line 5965  int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr
Line 6361  int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr
     return maxrs;      return maxrs;
 }  }
   
   ND nd_add_lf(ND p1,ND p2)
   {
       int n,c,can;
       ND r;
       NM m1,m2,mr0,mr,s;
       GZ t;
   
       if ( !p1 ) return p2;
       else if ( !p2 ) return p1;
       else {
           can = 0;
           for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {
               c = DL_COMPARE(DL(m1),DL(m2));
               switch ( c ) {
                   case 0:
                       addlf(CZ(m1),CZ(m2),&t);
                       s = m1; m1 = NEXT(m1);
                       if ( t ) {
                           can++; NEXTNM2(mr0,mr,s); CZ(mr) = (t);
                       } else {
                           can += 2; FREENM(s);
                       }
                       s = m2; m2 = NEXT(m2); FREENM(s);
                       break;
                   case 1:
                       s = m1; m1 = NEXT(m1); NEXTNM2(mr0,mr,s);
                       break;
                   case -1:
                       s = m2; m2 = NEXT(m2); NEXTNM2(mr0,mr,s);
                       break;
               }
           }
           if ( !mr0 )
               if ( m1 ) mr0 = m1;
               else if ( m2 ) mr0 = m2;
               else return 0;
           else if ( m1 ) NEXT(mr) = m1;
           else if ( m2 ) NEXT(mr) = m2;
           else NEXT(mr) = 0;
           BDY(p1) = mr0;
           SG(p1) = MAX(SG(p1),SG(p2));
           LEN(p1) = LEN(p1)+LEN(p2)-can;
           FREEND(p2);
           return p1;
       }
   }
   
   int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)
   {
       int i,j,k,len,pos,prev;
       mpz_t c,mc,c1;
       IndArray ivect;
       unsigned char *ivc;
       unsigned short *ivs;
       unsigned int *ivi;
       NDV redv;
       NMV mr;
       NODE rp;
       int maxrs;
   
       maxrs = 0;
       lf_lazy = 1;
       for ( i = 0; i < nred; i++ ) {
           ivect = imat[i];
           k = ivect->head;
           mpz_mod(svect[k],svect[k],BDY(current_mod_lf));
           if ( mpz_sgn(svect[k]) ) {
               maxrs = MAX(maxrs,rp0[i]->sugar);
               mpz_neg(svect[k],svect[k]);
               redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index];
               len = LEN(redv); mr = BDY(redv);
               prev = k;
               switch ( ivect->width ) {
                   case 1:
                       ivc = ivect->index.c;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivc[j]; prev = pos;
                           mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));
                       }
                       break;
                   case 2:
                       ivs = ivect->index.s;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivs[j]; prev = pos;
                           mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));
                       }
                       break;
                   case 4:
                       ivi = ivect->index.i;
                       for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                           pos = prev+ivi[j]; prev = pos;
                           mpz_addmul(svect[pos],svect[k],BDY(CZ(mr)));
                       }
                       break;
               }
               mpz_set_ui(svect[k],0);
           }
       }
       lf_lazy=0;
       for ( i = 0; i < col; i++ ) {
           mpz_mod(svect[i],svect[i],BDY(current_mod_lf));
       }
       return maxrs;
   }
   
   int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat)
   {
       int i,j,k,l,rank,s;
       mpz_t a,a1,inv;
       mpz_t *t,*pivot,*pk;
       mpz_t **mat;
       struct oEGT eg0,eg1,eg_forward,eg_mod,eg_back;
       int size,size1;
   
       mpz_init(inv);
       mpz_init(a);
       mat = (mpz_t **)mat0;
           size = 0;
       for ( rank = 0, j = 0; j < col; j++ ) {
           for ( i = rank; i < row; i++ ) {
               mpz_mod(mat[i][j],mat[i][j],BDY(current_mod_lf));
           }
           for ( i = rank; i < row; i++ )
               if ( mpz_sgn(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;
               s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s;
           }
           pivot = mat[rank];
           s = sugar[rank];
           mpz_invert(inv,pivot[j],BDY(current_mod_lf));
           for ( k = j, pk = pivot+k; k < col; k++, pk++ )
               if ( mpz_sgn(*pk) ) {
                   mpz_mul(a,*pk,inv); mpz_mod(*pk,a,BDY(current_mod_lf));
               }
           for ( i = rank+1; i < row; i++ ) {
               t = mat[i];
               if ( mpz_sgn(t[j]) ) {
                   sugar[i] = MAX(sugar[i],s);
                   mpz_neg(a,t[j]);
                   red_by_vect_lf(t+j,pivot+j,a,col-j);
               }
           }
           rank++;
       }
       for ( j = col-1, l = rank-1; j >= 0; j-- )
           if ( colstat[j] ) {
               pivot = mat[l];
               s = sugar[l];
               for ( k = j; k < col; k++ )
                 mpz_mod(pivot[k],pivot[k],BDY(current_mod_lf));
               for ( i = 0; i < l; i++ ) {
                   t = mat[i];
                   if ( mpz_sgn(t[j]) ) {
                       sugar[i] = MAX(sugar[i],s);
                       mpz_neg(a,t[j]);
                       red_by_vect_lf(t+j,pivot+j,a,col-j);
                   }
               }
               l--;
           }
       for ( j = 0, l = 0; l < rank; j++ )
           if ( colstat[j] ) {
               t = mat[l];
               for ( k = j; k < col; k++ ) {
                   mpz_mod(t[k],t[k],BDY(current_mod_lf));
               }
               l++;
           }
       return rank;
   }
   
   
 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhead,UINT *s0vect)  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhead,UINT *s0vect)
 {  {
     int j,k,len;      int j,k,len;
Line 5993  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
Line 6568  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
     }      }
 }  }
   
   #if defined(__GNUC__) && SIZEOF_LONG==8
   NDV vect64_to_ndv(U64 *vect,int spcol,int col,int *rhead,UINT *s0vect)
   {
       int j,k,len;
       UINT *p;
       UINT c;
       NDV r;
       NMV mr0,mr;
   
       for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;
       if ( !len ) return 0;
       else {
           mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len);
   #if 0
           ndv_alloc += nmv_adv*len;
   #endif
           mr = mr0;
           p = s0vect;
           for ( j = k = 0; j < col; j++, p += nd_wpd )
               if ( !rhead[j] ) {
                   if ( c = (UINT)vect[k++] ) {
                       ndl_copy(p,DL(mr)); CM(mr) = c; NMV_ADV(mr);
                   }
               }
           MKNDV(nd_nvar,mr0,len,r);
           return r;
       }
   }
   #endif
   
 NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect)  NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect)
 {  {
     int j,k,len;      int j,k,len;
Line 6051  NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe
Line 6656  NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe
 {  {
     int j,k,len;      int j,k,len;
     UINT *p;      UINT *p;
     Q c;      GZ c;
     NDV r;      NDV r;
     NMV mr0,mr;      NMV mr0,mr;
   
Line 6075  NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe
Line 6680  NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhe
     }      }
 }  }
   
   NDV vect_to_ndv_lf(mpz_t *vect,int spcol,int col,int *rhead,UINT *s0vect)
   {
       int j,k,len;
       UINT *p;
       mpz_t c;
       NDV r;
       NMV mr0,mr;
   
       for ( j = 0, len = 0; j < spcol; j++ ) if ( mpz_sgn(vect[j]) ) len++;
       if ( !len ) return 0;
       else {
           mr0 = (NMV)MALLOC(nmv_adv*len);
   #if 0
           ndv_alloc += nmv_adv*len;
   #endif
           mr = mr0;
           p = s0vect;
           for ( j = k = 0; j < col; j++, p += nd_wpd )
               if ( !rhead[j] ) {
                   c[0] = vect[k++][0];
                   if ( mpz_sgn(c) ) {
                       ndl_copy(p,DL(mr)); MPZTOGZ(c,CZ(mr)); NMV_ADV(mr);
                   }
               }
           MKNDV(nd_nvar,mr0,len,r);
           return r;
       }
   }
   
 /* for plain vector */  /* for plain vector */
   
 NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)  NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)
Line 6132  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 6766  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
     NM_ind_pair pair;      NM_ind_pair pair;
     ND red;      ND red;
     NDV *ps;      NDV *ps;
       static int afo;
   
     s0 = 0; rp0 = 0; col = 0;      s0 = 0; rp0 = 0; col = 0;
         if ( nd_demand )          if ( nd_demand )
Line 6149  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 6784  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
             h = nd_psh[index];              h = nd_psh[index];
             NEWNM(mul);              NEWNM(mul);
             ndl_sub(DL(head),DL(h),DL(mul));              ndl_sub(DL(head),DL(h),DL(mul));
             if ( ndl_check_bound2(index,DL(mul)) ) return 0;              if ( ndl_check_bound2(index,DL(mul)) )
                   return 0;
             sugar = TD(DL(mul))+SG(ps[index]);              sugar = TD(DL(mul))+SG(ps[index]);
             MKNM_ind_pair(pair,mul,index,sugar);              MKNM_ind_pair(pair,mul,index,sugar);
             red = ndv_mul_nm_symbolic(mul,ps[index]);              red = ndv_mul_nm_symbolic(mul,ps[index]);
Line 6168  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 6804  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
     return col;      return col;
 }  }
   
 NODE nd_f4(int m,int **indp)  void print_ndp(ND_pairs l)
 {  {
     int i,nh,stat,index;    ND_pairs t;
   
     for ( t = l; t; t = NEXT(t) )
       printf("[%d,%d] ",t->i1,t->i2);
     printf("\n");
   }
   
   NODE nd_f4(int m,int checkonly,int **indp)
   {
       int i,nh,stat,index,f4red;
     NODE r,g,tn0,tn,node;      NODE r,g,tn0,tn,node;
     ND_pairs d,l,t,ll0,ll;      ND_pairs d,l,t,ll0,ll,lh;
         LIST l0,l1;          LIST l0,l1;
     ND spol,red;      ND spol,red;
     NDV nf,redv;      NDV nf,redv;
     NM s0,s;      NM s0,s;
     NODE rp0,srp0,nflist,nzlist;      NODE rp0,srp0,nflist,nzlist,nzlist_t;
     int nsp,nred,col,rank,len,k,j,a,i1s,i2s;      int nsp,nred,col,rank,len,k,j,a,i1s,i2s;
     UINT c;      UINT c;
     UINT **spmat;      UINT **spmat;
Line 6186  NODE nd_f4(int m,int **indp)
Line 6831  NODE nd_f4(int m,int **indp)
     IndArray *imat;      IndArray *imat;
     int *rhead;      int *rhead;
     int spcol,sprow;      int spcol,sprow;
     int sugar;      int sugar,sugarh;
     PGeoBucket bucket;      PGeoBucket bucket;
     struct oEGT eg0,eg1,eg_f4;      struct oEGT eg0,eg1,eg_f4;
     Q i1,i2,sugarq;      Q i1,i2,sugarq;
Line 6199  NODE nd_f4(int m,int **indp)
Line 6844  NODE nd_f4(int m,int **indp)
         g = update_base(g,i);          g = update_base(g,i);
     }      }
         nzlist = 0;          nzlist = 0;
       nzlist_t = nd_nzlist;
       f4red = 1;
       nd_last_nonzero = 0;
     while ( d ) {      while ( d ) {
         get_eg(&eg0);          get_eg(&eg0);
         l = nd_minsugarp(d,&d);          l = nd_minsugarp(d,&d);
         sugar = SG(l);          sugar = nd_sugarweight?l->sugar2:SG(l);
         if ( nd_nzlist ) {          if ( MaxDeg > 0 && sugar > MaxDeg ) break;
             for ( tn = nd_nzlist; tn; tn = NEXT(tn) ) {          if ( nzlist_t ) {
                 node = BDY((LIST)BDY(tn));              node = BDY((LIST)BDY(nzlist_t));
                             if ( QTOS((Q)ARG0(node)) == sugar ) break;              sugarh = QTOS((Q)ARG0(node));
               tn = BDY((LIST)ARG1(node));
               if ( !tn ) {
                 nzlist_t = NEXT(nzlist_t);
                 continue;
             }              }
                         if ( tn ) {              /* tn = [[i1,i2],...] */
                                 for ( t = l, ll0 = 0; t; t = NEXT(t) ) {              lh = nd_ipairtospair(tn);
                         for ( tn = BDY((LIST)ARG1(node)); tn; tn = NEXT(tn) ) {  
                                         i1s = QTOS((Q)ARG0(BDY((LIST)BDY(tn))));  
                                         i2s = QTOS((Q)ARG1(BDY((LIST)BDY(tn))));  
                                         if ( t->i1 == i1s && t->i2 == i2s ) break;  
                                         }  
                                 if ( tn ) {  
                                         if ( !ll0 ) ll0 = t;  
                                                 else NEXT(ll) = t;  
                                                 ll = t;  
                                         }  
                 }  
                                 if ( ll0 ) NEXT(ll) = 0;  
                         l = ll0;  
                         } else l = 0;  
         }          }
         bucket = create_pbucket();          bucket = create_pbucket();
         stat = nd_sp_f4(m,0,l,bucket);          stat = nd_sp_f4(m,0,l,bucket);
Line 6243  NODE nd_f4(int m,int **indp)
Line 6881  NODE nd_f4(int m,int **indp)
         }          }
         get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);          get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);
         if ( DP_Print )          if ( DP_Print )
             fprintf(asir_out,"sugar=%d,symb=%fsec,",              fprintf(asir_out,"sugar=%d,symb=%.3fsec,",
                 sugar,eg_f4.exectime+eg_f4.gctime);                  sugar,eg_f4.exectime+eg_f4.gctime);
         nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0);          nflist = nd_f4_red(m,nd_nzlist?lh:l,0,s0vect,col,rp0,nd_gentrace?&ll:0);
           if ( checkonly && nflist ) return 0;
         /* adding new bases */          /* adding new bases */
           if ( nflist ) nd_last_nonzero = f4red;
         for ( r = nflist; r; r = NEXT(r) ) {          for ( r = nflist; r; r = NEXT(r) ) {
             nf = (NDV)BDY(r);              nf = (NDV)BDY(r);
             ndv_removecont(m,nf);              ndv_removecont(m,nf);
Line 6262  NODE nd_f4(int m,int **indp)
Line 6902  NODE nd_f4(int m,int **indp)
             d = update_pairs(d,g,nh,0);              d = update_pairs(d,g,nh,0);
             g = update_base(g,nh);              g = update_base(g,nh);
         }          }
           if ( DP_Print ) {
             fprintf(asir_out,"f4red=%d,gblen=%d\n",f4red,length(g)); fflush(asir_out);
           }
         if ( nd_gentrace ) {          if ( nd_gentrace ) {
                         for ( t = ll, tn0 = 0; t; t = NEXT(t) ) {                          for ( t = ll, tn0 = 0; t; t = NEXT(t) ) {
                                 NEXTNODE(tn0,tn);                                  NEXTNODE(tn0,tn);
Line 6273  NODE nd_f4(int m,int **indp)
Line 6916  NODE nd_f4(int m,int **indp)
             STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node);              STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node);
             MKNODE(node,l1,nzlist); nzlist = node;              MKNODE(node,l1,nzlist); nzlist = node;
         }          }
           if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t);
           f4red++;
           if ( nd_f4red && f4red > nd_f4red ) break;
           if ( nd_rank0 && !nflist ) break;
     }      }
     if ( nd_gentrace ) {      if ( nd_gentrace ) {
                 MKLIST(l0,reverse_node(nzlist));                  MKLIST(l0,reverse_node(nzlist));
Line 6315  NODE nd_f4_trace(int m,int **indp)
Line 6962  NODE nd_f4_trace(int m,int **indp)
         get_eg(&eg0);          get_eg(&eg0);
         l = nd_minsugarp(d,&d);          l = nd_minsugarp(d,&d);
         sugar = SG(l);          sugar = SG(l);
           if ( MaxDeg > 0 && sugar > MaxDeg ) break;
         bucket = create_pbucket();          bucket = create_pbucket();
         stat = nd_sp_f4(m,0,l,bucket);          stat = nd_sp_f4(m,0,l,bucket);
         if ( !stat ) {          if ( !stat ) {
Line 6333  NODE nd_f4_trace(int m,int **indp)
Line 6981  NODE nd_f4_trace(int m,int **indp)
         }          }
         get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);          get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);
         if ( DP_Print )          if ( DP_Print )
             fprintf(asir_out,"sugar=%d,symb=%fsec,",              fprintf(asir_out,"sugar=%d,symb=%.3fsec,",
                 sugar,eg_f4.exectime+eg_f4.gctime);                  sugar,eg_f4.exectime+eg_f4.gctime);
         nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);          nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);
         if ( !l0 ) continue;          if ( !l0 ) continue;
Line 6385  NODE nd_f4_trace(int m,int **indp)
Line 7033  NODE nd_f4_trace(int m,int **indp)
     return g;      return g;
 }  }
   
 NODE nd_f4_pseudo_trace(int m,int **indp)  
 {  
     int i,nh,stat,index;  
     NODE r,g;  
     ND_pairs d,l,l0,t;  
     ND spol,red;  
     NDV nf,redv,nfqv,nfv;  
     NM s0,s;  
     NODE rp0,srp0,nflist;  
     int nsp,nred,col,rank,len,k,j,a;  
     UINT c;  
     UINT **spmat;  
     UINT *s0vect,*svect,*p,*v;  
     int *colstat;  
     IndArray *imat;  
     int *rhead;  
     int spcol,sprow;  
     int sugar;  
     PGeoBucket bucket;  
     struct oEGT eg0,eg1,eg_f4;  
   
     g = 0; d = 0;  
     for ( i = 0; i < nd_psn; i++ ) {  
         d = update_pairs(d,g,i,0);  
         g = update_base(g,i);  
     }  
     while ( d ) {  
         get_eg(&eg0);  
         l = nd_minsugarp(d,&d);  
         sugar = SG(l);  
         bucket = create_pbucket();  
         stat = nd_sp_f4(m,0,l,bucket);  
         if ( !stat ) {  
             for ( t = l; NEXT(t); t = NEXT(t) );  
             NEXT(t) = d; d = l;  
             d = nd_reconstruct(1,d);  
             continue;  
         }  
         if ( bucket->m < 0 ) continue;  
         col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0);  
         if ( !col ) {  
             for ( t = l; NEXT(t); t = NEXT(t) );  
             NEXT(t) = d; d = l;  
             d = nd_reconstruct(1,d);  
             continue;  
         }  
         get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);  
         if ( DP_Print )  
             fprintf(asir_out,"sugar=%d,symb=%fsec,",  
                 sugar,eg_f4.exectime+eg_f4.gctime);  
         nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);  
         if ( !l0 ) continue;  
         l = l0;  
   
         /* over Q */  
                 while ( 1 ) {  
                 bucket = create_pbucket();  
                 stat = nd_sp_f4(0,1,l,bucket);  
                 if ( !stat ) {  
                 for ( t = l; NEXT(t); t = NEXT(t) );  
                 NEXT(t) = d; d = l;  
                 d = nd_reconstruct(1,d);  
                 continue;  
                 }  
                 if ( bucket->m < 0 ) continue;  
                 col = nd_symbolic_preproc(bucket,1,&s0vect,&rp0);  
                 if ( !col ) {  
                 for ( t = l; NEXT(t); t = NEXT(t) );  
                 NEXT(t) = d; d = l;  
                 d = nd_reconstruct(1,d);  
                 continue;  
                 }  
                 nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0);  
                 }  
   
         /* adding new bases */  
         for ( r = nflist; r; r = NEXT(r) ) {  
             nfqv = (NDV)BDY(r);  
             ndv_removecont(0,nfqv);  
             if ( !rem(NM(HCQ(nfqv)),m) ) return 0;  
             if ( nd_nalg ) {  
                 ND nf1;  
   
                 nf1 = ndvtond(m,nfqv);  
                 nd_monic(0,&nf1);  
                 nd_removecont(0,nf1);  
                 nfqv = ndtondv(0,nf1); nd_free(nf1);  
             }  
             nfv = ndv_dup(0,nfqv);  
             ndv_mod(m,nfv);  
             ndv_removecont(m,nfv);  
             nh = ndv_newps(0,nfv,nfqv,1);  
             d = update_pairs(d,g,nh,0);  
             g = update_base(g,nh);  
         }  
     }  
 #if 0  
     fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);  
 #endif  
         conv_ilist(0,1,g,indp);  
     return g;  
 }  
   
 int rref(matrix mat,int *sugar)  int rref(matrix mat,int *sugar)
 {  {
   int row,col,i,j,k,l,s,wcol,wj;    int row,col,i,j,k,l,s,wcol,wj;
Line 6570  void red_by_vect_2(matrix mat,int *sugar,unsigned long
Line 7115  void red_by_vect_2(matrix mat,int *sugar,unsigned long
   row = mat->row;    row = mat->row;
   col = mat->col;    col = mat->col;
   wcol = (col+BLEN-1)/BLEN;    wcol = (col+BLEN-1)/BLEN;
   pos = (int *)ALLOCA(wcol*sizeof(int));    pos = (int *)MALLOC(wcol*sizeof(int));
   bzero(pos,wcol*sizeof(int));    bzero(pos,wcol*sizeof(int));
   for ( i = j = 0; i < wcol; i++ )    for ( i = j = 0; i < wcol; i++ )
     if ( v[i] ) pos[j++] = i;;      if ( v[i] ) pos[j++] = i;;
Line 6610  init_eg(&eg_search);
Line 7155  init_eg(&eg_search);
     for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );      for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );
     nred = length(rp0);      nred = length(rp0);
     mat = alloc_matrix(nsp,col);      mat = alloc_matrix(nsp,col);
     s0hash = (int *)ALLOCA(col*sizeof(int));      s0hash = (int *)MALLOC(col*sizeof(int));
     for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )      for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )
         s0hash[i] = ndl_hash_value(s);          s0hash[i] = ndl_hash_value(s);
   
         sugar = (int *)ALLOCA(nsp*sizeof(int));          sugar = (int *)MALLOC(nsp*sizeof(int));
         for ( i = 0, sp = sp0; sp; sp = NEXT(sp) ) {          for ( i = 0, sp = sp0; sp; sp = NEXT(sp) ) {
                 nd_sp(2,0,sp,&spol);                  nd_sp(2,0,sp,&spol);
                 if ( spol ) {                  if ( spol ) {
Line 6624  init_eg(&eg_search);
Line 7169  init_eg(&eg_search);
                 }                  }
         }          }
         mat->row = i;          mat->row = i;
     fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out);      if ( DP_Print ) {
         fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out);
       }
         size = ((col+BLEN-1)/BLEN)*sizeof(unsigned long);          size = ((col+BLEN-1)/BLEN)*sizeof(unsigned long);
         v = CALLOC((col+BLEN-1)/BLEN,sizeof(unsigned long));          v = CALLOC((col+BLEN-1)/BLEN,sizeof(unsigned long));
     for ( rp = rp0, i = 0; rp; rp = NEXT(rp), i++ ) {      for ( rp = rp0, i = 0; rp; rp = NEXT(rp), i++ ) {
Line 6648  init_eg(&eg_search);
Line 7195  init_eg(&eg_search);
     get_eg(&eg2);      get_eg(&eg2);
     init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2);      init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim1=%fsec,elim2=%fsec\n",          fprintf(asir_out,"elim1=%.3fsec,elim2=%.3fsec,",
                   eg_elim1.exectime+eg_elim1.gctime,eg_elim2.exectime+eg_elim2.gctime);                    eg_elim1.exectime+eg_elim1.gctime,eg_elim2.exectime+eg_elim2.gctime);
         fflush(asir_out);          fflush(asir_out);
         }          }
Line 6673  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
Line 7220  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
 init_eg(&eg_search);  init_eg(&eg_search);
     for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );      for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );
     nred = length(rp0);      nred = length(rp0);
     imat = (IndArray *)ALLOCA(nred*sizeof(IndArray));      imat = (IndArray *)MALLOC(nred*sizeof(IndArray));
     rhead = (int *)ALLOCA(col*sizeof(int));      rhead = (int *)MALLOC(col*sizeof(int));
     for ( i = 0; i < col; i++ ) rhead[i] = 0;      for ( i = 0; i < col; i++ ) rhead[i] = 0;
   
     /* construction of index arrays */      /* construction of index arrays */
         fprintf(stderr,"%dx%d,",nsp+nred,col);      if ( DP_Print ) {
     rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair));            fprintf(asir_out,"%dx%d,",nsp+nred,col);
     s0hash = (int *)ALLOCA(col*sizeof(int));      }
       rvect = (NM_ind_pair *)MALLOC(nred*sizeof(NM_ind_pair));
       s0hash = (int *)MALLOC(col*sizeof(int));
     for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )      for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )
         s0hash[i] = ndl_hash_value(s);          s0hash[i] = ndl_hash_value(s);
     for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {      for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {
         rvect[i] = (NM_ind_pair)BDY(rp);          rvect[i] = (NM_ind_pair)BDY(rp);
         imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,s0hash,rvect[i]);          imat[i] = nm_ind_pair_to_vect_compress(trace,s0vect,col,s0hash,rvect[i]);
         rhead[imat[i]->head] = 1;          rhead[imat[i]->head] = 1;
     }      }
     if ( m )      if ( m > 0 )
   #if defined(__GNUC__) && SIZEOF_LONG==8
           r0 = nd_f4_red_mod64_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);
   #else
         r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);          r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);
   #endif
       else if ( m == -1 )
           r0 = nd_f4_red_sf_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);
       else if ( m == -2 )
           r0 = nd_f4_red_lf_main(m,sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);
     else      else
   #if defined(VISUAL)
           r0 = nd_f4_red_q_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);
   #else
         r0 = nd_f4_red_gz_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);          r0 = nd_f4_red_gz_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);
 print_eg("search",&eg_search);  #endif
   #if 0
       if ( DP_Print ) print_eg("search",&eg_search);
   #endif
     return r0;      return r0;
 }  }
   
   /* for Fp, 2<=p<2^16 */
   
 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,
         NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)          NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)
 {  {
Line 6715  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 7280  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
     spcol = col-nred;      spcol = col-nred;
     get_eg(&eg0);      get_eg(&eg0);
     /* elimination (1st step) */      /* elimination (1st step) */
     spmat = (int **)ALLOCA(nsp*sizeof(UINT *));      spmat = (int **)MALLOC(nsp*sizeof(UINT *));
     svect = (UINT *)ALLOCA(col*sizeof(UINT));      svect = (UINT *)MALLOC(col*sizeof(UINT));
     spsugar = (int *)ALLOCA(nsp*sizeof(UINT));      spsugar = (int *)MALLOC(nsp*sizeof(int));
     spactive = !nz?0:(ND_pairs *)ALLOCA(nsp*sizeof(ND_pairs));      spactive = !nz?0:(ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));
     for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {      for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
         nd_sp(m,0,sp,&spol);          nd_sp(m,0,sp,&spol);
         if ( !spol ) continue;          if ( !spol ) continue;
Line 6741  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 7306  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
     }      }
     get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);      get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim1=%fsec,",eg_f4_1.exectime+eg_f4_1.gctime);          fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
         fflush(asir_out);          fflush(asir_out);
     }      }
     /* free index arrays */      /* free index arrays */
     for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c);      for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c);
   
     /* elimination (2nd step) */      /* elimination (2nd step) */
     colstat = (int *)ALLOCA(spcol*sizeof(int));      colstat = (int *)MALLOC(spcol*sizeof(int));
     if ( m == -1 )      if ( m == -1 )
         rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);          rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);
     else      else
Line 6766  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 7331  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
     get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);      get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
     init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);      init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim2=%fsec\n",eg_f4_2.exectime+eg_f4_2.gctime);          fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
         fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d  ",          fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
             nsp,nred,sprow,spcol,rank);              nsp,nred,sprow,spcol,rank);
         fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);          fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
     }      }
     if ( nz ) {      if ( nz ) {
         for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];          for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];
Line 6782  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 7347  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
     return r0;      return r0;
 }  }
   
   #if defined(__GNUC__) && SIZEOF_LONG==8
   /* for Fp, 2^15=<p<2^29 */
   
   NODE nd_f4_red_mod64_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)
   {
       int spcol,sprow,a;
       int i,j,k,l,rank;
       NODE r0,r;
       ND_pairs sp;
       ND spol;
       U64 **spmat;
       U64 *svect,*cvect;
       U64 *v;
       int *colstat;
       struct oEGT eg0,eg1,eg2,eg_f4,eg_f4_1,eg_f4_2;
       int maxrs;
       int *spsugar;
       ND_pairs *spactive;
   
       spcol = col-nred;
       get_eg(&eg0);
       /* elimination (1st step) */
       spmat = (U64 **)MALLOC(nsp*sizeof(U64 *));
       svect = (U64 *)MALLOC(col*sizeof(U64));
       cvect = (U64 *)MALLOC(col*sizeof(U64));
       spsugar = (int *)MALLOC(nsp*sizeof(int));
       spactive = !nz?0:(ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));
       for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
           nd_sp(m,0,sp,&spol);
           if ( !spol ) continue;
           nd_to_vect64(m,s0vect,col,spol,svect);
           maxrs = ndv_reduce_vect64(m,svect,cvect,col,imat,rvect,nred);
           for ( i = 0; i < col; i++ ) if ( svect[i] ) break;
           if ( i < col ) {
               spmat[sprow] = v = (U64 *)MALLOC_ATOMIC(spcol*sizeof(U64));
               for ( j = k = 0; j < col; j++ )
                   if ( !rhead[j] ) v[k++] = (UINT)svect[j];
               spsugar[sprow] = MAX(maxrs,SG(spol));
               if ( nz )
               spactive[sprow] = sp;
               sprow++;
           }
           nd_free(spol);
       }
       get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
       if ( DP_Print ) {
           fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
           fflush(asir_out);
       }
       /* free index arrays */
       for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c);
   
       /* elimination (2nd step) */
       colstat = (int *)MALLOC(spcol*sizeof(int));
       rank = nd_gauss_elim_mod64(spmat,spsugar,spactive,sprow,spcol,m,colstat);
       r0 = 0;
       for ( i = 0; i < rank; i++ ) {
           NEXTNODE(r0,r); BDY(r) =
             (pointer)vect64_to_ndv(spmat[i],spcol,col,rhead,s0vect);
           SG((NDV)BDY(r)) = spsugar[i];
           GCFREE(spmat[i]);
       }
       if ( r0 ) NEXT(r) = 0;
   
       for ( ; i < sprow; i++ ) GCFREE(spmat[i]);
       get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
       init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
       if ( DP_Print ) {
           fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
           fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
               nsp,nred,sprow,spcol,rank);
           fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
       }
       if ( nz ) {
           for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];
           if ( rank > 0 ) {
               NEXT(spactive[rank-1]) = 0;
               *nz = spactive[0];
           } else
               *nz = 0;
       }
       return r0;
   }
   #endif
   
   /* for small finite fields */
   
   NODE nd_f4_red_sf_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz)
   {
       int spcol,sprow,a;
       int i,j,k,l,rank;
       NODE r0,r;
       ND_pairs sp;
       ND spol;
       int **spmat;
       UINT *svect,*v;
       int *colstat;
       struct oEGT eg0,eg1,eg2,eg_f4,eg_f4_1,eg_f4_2;
       int maxrs;
       int *spsugar;
       ND_pairs *spactive;
   
       spcol = col-nred;
       get_eg(&eg0);
       /* elimination (1st step) */
       spmat = (int **)MALLOC(nsp*sizeof(UINT *));
       svect = (UINT *)MALLOC(col*sizeof(UINT));
       spsugar = (int *)MALLOC(nsp*sizeof(int));
       spactive = !nz?0:(ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));
       for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
           nd_sp(m,0,sp,&spol);
           if ( !spol ) continue;
           nd_to_vect(m,s0vect,col,spol,svect);
           maxrs = ndv_reduce_vect_sf(m,svect,col,imat,rvect,nred);
           for ( i = 0; i < col; i++ ) if ( svect[i] ) break;
           if ( i < col ) {
               spmat[sprow] = v = (UINT *)MALLOC_ATOMIC(spcol*sizeof(UINT));
               for ( j = k = 0; j < col; j++ )
                   if ( !rhead[j] ) v[k++] = svect[j];
               spsugar[sprow] = MAX(maxrs,SG(spol));
               if ( nz )
               spactive[sprow] = sp;
               sprow++;
           }
           nd_free(spol);
       }
       get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
       if ( DP_Print ) {
           fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
           fflush(asir_out);
       }
       /* free index arrays */
       for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c);
   
       /* elimination (2nd step) */
       colstat = (int *)MALLOC(spcol*sizeof(int));
       rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);
       r0 = 0;
       for ( i = 0; i < rank; i++ ) {
           NEXTNODE(r0,r); BDY(r) =
               (pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);
           SG((NDV)BDY(r)) = spsugar[i];
           GCFREE(spmat[i]);
       }
       if ( r0 ) NEXT(r) = 0;
   
       for ( ; i < sprow; i++ ) GCFREE(spmat[i]);
       get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
       init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
       if ( DP_Print ) {
           fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
           fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
               nsp,nred,sprow,spcol,rank);
           fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
       }
       if ( nz ) {
           for ( i = 0; i < rank-1; i++ ) NEXT(spactive[i]) = spactive[i+1];
           if ( rank > 0 ) {
               NEXT(spactive[rank-1]) = 0;
               *nz = spactive[0];
           } else
               *nz = 0;
       }
       return r0;
   }
   
   NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,
           NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred)
   {
       int spcol,sprow,a;
       int i,j,k,l,rank;
       NODE r0,r;
       ND_pairs sp;
       ND spol;
       mpz_t **spmat;
       mpz_t *svect,*v;
       int *colstat;
       struct oEGT eg0,eg1,eg2,eg_f4,eg_f4_1,eg_f4_2;
       int maxrs;
       int *spsugar;
       pointer *w;
   
       spcol = col-nred;
       get_eg(&eg0);
       /* elimination (1st step) */
       spmat = (mpz_t **)MALLOC(nsp*sizeof(mpz_t *));
       svect = (mpz_t *)MALLOC(col*sizeof(mpz_t));
       spsugar = (int *)MALLOC(nsp*sizeof(int));
       for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
           nd_sp(m,trace,sp,&spol);
           if ( !spol ) continue;
           nd_to_vect_lf(s0vect,col,spol,svect);
           maxrs = ndv_reduce_vect_lf(svect,trace,col,imat,rvect,nred);
           for ( i = 0; i < col; i++ ) if ( mpz_sgn(svect[i]) ) break;
           if ( i < col ) {
               spmat[sprow] = v = (mpz_t *)MALLOC(spcol*sizeof(mpz_t));
               for ( j = k = 0; j < col; j++ )
                   if ( !rhead[j] ) v[k++][0] = svect[j][0];
               spsugar[sprow] = MAX(maxrs,SG(spol));
               sprow++;
           }
   /*        nd_free(spol); */
       }
       get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
       if ( DP_Print ) {
           fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
           fflush(asir_out);
       }
       /* free index arrays */
   /*    for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */
   
       /* elimination (2nd step) */
       colstat = (int *)MALLOC(spcol*sizeof(int));
       rank = nd_gauss_elim_lf(spmat,spsugar,sprow,spcol,colstat);
       w = (pointer *)MALLOC(rank*sizeof(pointer));
       for ( i = 0; i < rank; i++ ) {
   #if 0
           w[rank-i-1] = (pointer)vect_to_ndv_lf(spmat[i],spcol,col,rhead,s0vect);
           SG((NDV)w[rank-i-1]) = spsugar[i];
   #else
           w[i] = (pointer)vect_to_ndv_lf(spmat[i],spcol,col,rhead,s0vect);
           SG((NDV)w[i]) = spsugar[i];
   #endif
   /*        GCFREE(spmat[i]); */
   
       }
   #if 0
       qsort(w,rank,sizeof(NDV),
           (int (*)(const void *,const void *))ndv_compare);
   #endif
       r0 = 0;
       for ( i = 0; i < rank; i++ ) {
           NEXTNODE(r0,r); BDY(r) = w[i];
       }
       if ( r0 ) NEXT(r) = 0;
   
   /*    for ( ; i < sprow; i++ ) GCFREE(spmat[i]); */
       get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
       init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
       if ( DP_Print ) {
           fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
           fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
               nsp,nred,sprow,spcol,rank);
           fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
       }
       return r0;
   }
   
 #if 1  #if 1
 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,
         NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred)          NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred)
Line 6802  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 7617  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
     spcol = col-nred;      spcol = col-nred;
     get_eg(&eg0);      get_eg(&eg0);
     /* elimination (1st step) */      /* elimination (1st step) */
     spmat = (Q **)ALLOCA(nsp*sizeof(Q *));      spmat = (Q **)MALLOC(nsp*sizeof(Q *));
     svect = (Q *)ALLOCA(col*sizeof(Q));      svect = (Q *)MALLOC(col*sizeof(Q));
     spsugar = (int *)ALLOCA(nsp*sizeof(Q));      spsugar = (int *)MALLOC(nsp*sizeof(int));
     for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {      for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
         nd_sp(0,trace,sp,&spol);          nd_sp(0,trace,sp,&spol);
         if ( !spol ) continue;          if ( !spol ) continue;
Line 6822  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 7637  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
     }      }
     get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);      get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim1=%fsec,",eg_f4_1.exectime+eg_f4_1.gctime);          fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
         fflush(asir_out);          fflush(asir_out);
     }      }
     /* free index arrays */      /* free index arrays */
 /*    for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */  /*    for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */
   
     /* elimination (2nd step) */      /* elimination (2nd step) */
     colstat = (int *)ALLOCA(spcol*sizeof(int));      colstat = (int *)MALLOC(spcol*sizeof(int));
     rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat);      rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat);
     w = (pointer *)ALLOCA(rank*sizeof(pointer));      w = (pointer *)MALLOC(rank*sizeof(pointer));
     for ( i = 0; i < rank; i++ ) {      for ( i = 0; i < rank; i++ ) {
 #if 0  #if 0
         w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);          w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);
Line 6856  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 7671  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
     get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);      get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
     init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);      init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim2=%fsec\n",eg_f4_2.exectime+eg_f4_2.gctime);          fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
         fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d  ",          fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
             nsp,nred,sprow,spcol,rank);              nsp,nred,sprow,spcol,rank);
         fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);          fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
     }      }
     return r0;      return r0;
 }  }
Line 6883  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
Line 7698  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
     spcol = col-nred;      spcol = col-nred;
     get_eg(&eg0);      get_eg(&eg0);
     /* elimination (1st step) */      /* elimination (1st step) */
     spmat = (GZ **)ALLOCA(nsp*sizeof(GZ *));      spmat = (GZ **)MALLOC(nsp*sizeof(GZ *));
     svect = (GZ *)ALLOCA(col*sizeof(GZ));      svect = (GZ *)MALLOC(col*sizeof(GZ));
     spsugar = (int *)ALLOCA(nsp*sizeof(Q));      spsugar = (int *)MALLOC(nsp*sizeof(int));
     for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {      for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
         nd_sp(0,trace,sp,&spol);          nd_sp(0,trace,sp,&spol);
         if ( !spol ) continue;          if ( !spol ) continue;
Line 6904  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
Line 7719  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
     }      }
     get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);      get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim1=%fsec,",eg_f4_1.exectime+eg_f4_1.gctime);          fprintf(asir_out,"elim1=%.3fsec,",eg_f4_1.exectime+eg_f4_1.gctime);
         fflush(asir_out);          fflush(asir_out);
     }      }
     /* free index arrays */      /* free index arrays */
 /*    for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */  /*    for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */
   
     /* elimination (2nd step) */      /* elimination (2nd step) */
     colstat = (int *)ALLOCA(spcol*sizeof(int));      colstat = (int *)MALLOC(spcol*sizeof(int));
     rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat);      rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat);
     w = (pointer *)ALLOCA(rank*sizeof(pointer));      w = (pointer *)MALLOC(rank*sizeof(pointer));
     for ( i = 0; i < rank; i++ ) {      for ( i = 0; i < rank; i++ ) {
 #if 0  #if 0
         w[rank-i-1] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);          w[rank-i-1] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);
                 w[rank-i-1] = ndvgztondv(w[rank-i-1]);                  w[rank-i-1] = ndvgztondv(w[rank-i-1]);
         SG((NDV)w[rank-i-1]) = spsugar[i];          SG((NDV)w[rank-i-1]) = spsugar[i];
 #else  #else
         w[i] = (pointer)vect_to_ndv_gz((Q *)spmat[i],spcol,col,rhead,s0vect);          w[i] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);
                 w[i] = ndvgztondv(w[i]);                  w[i] = ndvgztondv(w[i]);
         SG((NDV)w[i]) = spsugar[i];          SG((NDV)w[i]) = spsugar[i];
 #endif  #endif
Line 6941  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
Line 7756  NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,
     get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);      get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);
     init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);      init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);
     if ( DP_Print ) {      if ( DP_Print ) {
         fprintf(asir_out,"elim2=%fsec\n",eg_f4_2.exectime+eg_f4_2.gctime);          fprintf(asir_out,"elim2=%.3fsec,",eg_f4_2.exectime+eg_f4_2.gctime);
         fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d  ",          fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",
             nsp,nred,sprow,spcol,rank);              nsp,nred,sprow,spcol,rank);
         fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);          fprintf(asir_out,"%.3fsec,",eg_f4.exectime+eg_f4.gctime);
     }      }
     return r0;      return r0;
 }  }
Line 6975  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec
Line 7790  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec
   
     row = nsp+nred;      row = nsp+nred;
     /* make the matrix */      /* make the matrix */
     mat = (Q **)ALLOCA(row*sizeof(Q *));      mat = (Q **)MALLOC(row*sizeof(Q *));
     sugar = (int *)ALLOCA(row*sizeof(int));      sugar = (int *)MALLOC(row*sizeof(int));
     for ( row = a = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {      for ( row = a = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
         nd_sp(0,0,sp,&spol);          nd_sp(0,0,sp,&spol);
         if ( !spol ) continue;          if ( !spol ) continue;
Line 6990  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec
Line 7805  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec
         sugar[row] = rvect[i]->sugar;          sugar[row] = rvect[i]->sugar;
     }      }
     /* elimination */      /* elimination */
     colstat = (int *)ALLOCA(col*sizeof(int));      colstat = (int *)MALLOC(col*sizeof(int));
     rank = nd_gauss_elim_q(mat,sugar,row,col,colstat);      rank = nd_gauss_elim_q(mat,sugar,row,col,colstat);
     r0 = 0;      r0 = 0;
     for ( i = 0; i < rank; i++ ) {      for ( i = 0; i < rank; i++ ) {
Line 7082  NDV nd_recv_ndv()
Line 7897  NDV nd_recv_ndv()
     }      }
 }  }
   
 int ox_exec_f4_red(Q proc)  
 {  
     Obj obj;  
     STRING fname;  
     NODE arg;  
     int s;  
     extern int ox_need_conv,ox_file_io;  
   
     MKSTR(fname,"nd_exec_f4_red");  
     arg = mknode(2,proc,fname);  
     Pox_cmo_rpc(arg,&obj);  
     s = get_ox_server_id(QTOS(proc));  
     nd_write = iofp[s].out;  
     nd_read = iofp[s].in;  
     ox_need_conv = ox_file_io = 0;  
     return s;  
 }  
   
 #if 0  
 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)  
 {  
     int nsp,nred;  
     int i,rank,s;  
     NODE rp,r0,r;  
     ND_pairs sp;  
     NM_ind_pair pair;  
     NMV nmv;  
     NM nm;  
     NDV nf;  
     Obj proc,dmy;  
   
     ox_launch_main(0,0,&proc);  
     s = ox_exec_f4_red((Q)proc);  
   
     nd_send_int(m);  
     nd_send_int(nd_nvar);  
     nd_send_int(nd_bpe);  
     nd_send_int(nd_wpd);  
     nd_send_int(nmv_adv);  
   
     saveobj(nd_write,dp_current_spec->obj); fflush(nd_write);  
   
     nd_send_int(nd_psn);  
     for ( i = 0; i < nd_psn; i++ ) nd_send_ndv(nd_ps[i]);  
   
     for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );  
     nd_send_int(nsp);  
     for ( i = 0, sp = sp0; i < nsp; i++, sp = NEXT(sp) ) {  
         nd_send_int(sp->i1); nd_send_int(sp->i2);  
     }  
   
     nd_send_int(col); nd_send_intarray(s0vect,col*nd_wpd);  
   
     nred = length(rp0); nd_send_int(nred);  
     for ( i = 0, rp = rp0; i < nred; i++, rp = NEXT(rp) ) {  
         pair = (NM_ind_pair)BDY(rp);  
         nd_send_int(pair->index);  
         nd_send_intarray(pair->mul->dl,nd_wpd);  
     }  
     fflush(nd_write);  
     rank = nd_recv_int();  
     fprintf(asir_out,"rank=%d\n",rank);  
     r0 = 0;  
     for ( i = 0; i < rank; i++ ) {  
         nf = nd_recv_ndv();  
         NEXTNODE(r0,r); BDY(r) = (pointer)nf;  
     }  
     Pox_shutdown(mknode(1,proc),&dmy);  
     return r0;  
 }  
   
 /* server side */  
   
 void nd_exec_f4_red_dist()  
 {  
     int m,i,nsp,col,s0size,nred,spcol,j,k;  
     NM_ind_pair *rp0;  
     NDV nf;  
     UINT *s0vect;  
     IndArray *imat;  
     int *rhead;  
     int **spmat;  
     UINT *svect,*v;  
     ND_pairs *sp0;  
     int *colstat;  
     int a,sprow,rank;  
     struct order_spec *ord;  
     Obj ordspec;  
     ND spol;  
     int maxrs;  
     int *spsugar;  
   
     nd_read = iofp[0].in;  
     nd_write = iofp[0].out;  
     m = nd_recv_int();  
     nd_nvar = nd_recv_int();  
     nd_bpe = nd_recv_int();  
     nd_wpd = nd_recv_int();  
     nmv_adv = nd_recv_int();  
   
     loadobj(nd_read,&ordspec);  
     create_order_spec(0,ordspec,&ord);  
     nd_init_ord(ord);  
     nd_setup_parameters(nd_nvar,0);  
   
     nd_psn = nd_recv_int();  
     nd_ps = (NDV *)MALLOC(nd_psn*sizeof(NDV));  
     nd_bound = (UINT **)MALLOC(nd_psn*sizeof(UINT *));  
     for ( i = 0; i < nd_psn; i++ ) {  
         nd_ps[i] = nd_recv_ndv();  
         nd_bound[i] = ndv_compute_bound(nd_ps[i]);  
     }  
   
     nsp = nd_recv_int();  
     sp0 = (ND_pairs *)MALLOC(nsp*sizeof(ND_pairs));  
     for ( i = 0; i < nsp; i++ ) {  
         NEWND_pairs(sp0[i]);  
         sp0[i]->i1 = nd_recv_int(); sp0[i]->i2 = nd_recv_int();  
         ndl_lcm(HDL(nd_ps[sp0[i]->i1]),HDL(nd_ps[sp0[i]->i2]),LCM(sp0[i]));  
     }  
   
     col = nd_recv_int();  
     s0size = col*nd_wpd;  
     s0vect = (UINT *)MALLOC(s0size*sizeof(UINT));  
     nd_recv_intarray(s0vect,s0size);  
   
     nred = nd_recv_int();  
     rp0 = (NM_ind_pair *)MALLOC(nred*sizeof(NM_ind_pair));  
     for ( i = 0; i < nred; i++ ) {  
         rp0[i] = (NM_ind_pair)MALLOC(sizeof(struct oNM_ind_pair));  
         rp0[i]->index = nd_recv_int();  
         rp0[i]->mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));  
         nd_recv_intarray(rp0[i]->mul->dl,nd_wpd);  
     }  
   
     spcol = col-nred;  
     imat = (IndArray *)MALLOC(nred*sizeof(IndArray));  
     rhead = (int *)MALLOC(col*sizeof(int));  
     for ( i = 0; i < col; i++ ) rhead[i] = 0;  
   
     /* construction of index arrays */  
     for ( i = 0; i < nred; i++ ) {  
         imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,rp0[i]);  
         rhead[imat[i]->head] = 1;  
     }  
   
     /* elimination (1st step) */  
     spmat = (int **)MALLOC(nsp*sizeof(UINT *));  
     svect = (UINT *)MALLOC(col*sizeof(UINT));  
     spsugar = (int *)ALLOCA(nsp*sizeof(UINT));  
     for ( a = sprow = 0; a < nsp; a++ ) {  
         nd_sp(m,0,sp0[a],&spol);  
         if ( !spol ) continue;  
         nd_to_vect(m,s0vect,col,spol,svect);  
         if ( m == -1 )  
             maxrs = ndv_reduce_vect_sf(m,svect,col,imat,rp0,nred);  
         else  
             maxrs = ndv_reduce_vect(m,svect,col,imat,rp0,nred);  
         for ( i = 0; i < col; i++ ) if ( svect[i] ) break;  
         if ( i < col ) {  
             spmat[sprow] = v = (UINT *)MALLOC(spcol*sizeof(UINT));  
             for ( j = k = 0; j < col; j++ )  
                 if ( !rhead[j] ) v[k++] = svect[j];  
             spsugar[sprow] = MAX(maxrs,SG(spol));  
             sprow++;  
         }  
         nd_free(spol);  
     }  
     /* elimination (2nd step) */  
     colstat = (int *)ALLOCA(spcol*sizeof(int));  
     if ( m == -1 )  
         rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat);  
     else  
         rank = nd_gauss_elim_mod(spmat,spsugar,0,sprow,spcol,m,colstat);  
     nd_send_int(rank);  
     for ( i = 0; i < rank; i++ ) {  
         nf = vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);  
         nd_send_ndv(nf);  
     }  
     fflush(nd_write);  
 }  
 #endif  
   
 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat)  int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat)
 {  {
     int i,j,t,c,rank,inv;      int i,j,t,c,rank,inv;
Line 7377  int nd_gauss_elim_mod(int **mat0,int *sugar,ND_pairs *
Line 8009  int nd_gauss_elim_mod(int **mat0,int *sugar,ND_pairs *
     return rank;      return rank;
 }  }
   
   #if defined(__GNUC__) && SIZEOF_LONG==8
   
   int nd_gauss_elim_mod64(U64 **mat,int *sugar,ND_pairs *spactive,int row,int col,int md,int *colstat)
   {
     int i,j,k,l,rank,s;
     U64 inv;
     U64 a;
     UINT c;
     U64 *t,*pivot,*pk;
     UINT *ck;
     UINT **cmat;
     UINT *ct;
     ND_pairs pair;
   
     cmat = (UINT **)MALLOC(row*sizeof(UINT *));
     for ( i = 0; i < row; i++ ) {
       cmat[i] = MALLOC_ATOMIC(col*sizeof(UINT));
       bzero(cmat[i],col*sizeof(UINT));
     }
   
     for ( rank = 0, j = 0; j < col; j++ ) {
       for ( i = rank; i < row; i++ ) {
         a = mat[i][j]; c = cmat[i][j];
         MOD128(a,c,md);
         mat[i][j] = a; cmat[i][j] = 0;
       }
       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;
         ct = cmat[i]; cmat[i] = cmat[rank]; cmat[rank] = ct;
         s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s;
         if ( spactive ) {
           pair = spactive[i]; spactive[i] = spactive[rank];
           spactive[rank] = pair;
         }
       }
       /* column j is normalized */
       s = sugar[rank];
       inv = invm((UINT)mat[rank][j],md);
       /* normalize pivot row */
       for ( k = j, pk = mat[rank]+j, ck = cmat[rank]+j; k < col; k++, pk++, ck++ ) {
         a = *pk; c = *ck; MOD128(a,c,md); *pk = (a*inv)%md; *ck = 0;
       }
       for ( i = rank+1; i < row; i++ ) {
         if ( a = mat[i][j] ) {
           sugar[i] = MAX(sugar[i],s);
           red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[rank]+j,(int)(md-a),col-j);
         }
       }
       rank++;
     }
     for ( j = col-1, l = rank-1; j >= 0; j-- )
       if ( colstat[j] ) {
         for ( k = j, pk = mat[l]+j, ck = cmat[l]+j; k < col; k++, pk++, ck++ ) {
           a = *pk; c = *ck; MOD128(a,c,md); *pk = a; *ck = 0;
         }
         s = sugar[l];
         for ( i = 0; i < l; i++ ) {
           a = mat[i][j]; c = cmat[i][j]; MOD128(a,c,md); mat[i][j] = a; cmat[i][j] = 0;
           if ( a ) {
             sugar[i] = MAX(sugar[i],s);
             red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[l]+j,(int)(md-a),col-j);
           }
         }
         l--;
       }
     for ( i = 0; i < row; i++ ) GCFREE(cmat[i]);
     GCFREE(cmat);
     return rank;
   }
   #endif
   
 int nd_gauss_elim_sf(int **mat0,int *sugar,int row,int col,int md,int *colstat)  int nd_gauss_elim_sf(int **mat0,int *sugar,int row,int col,int md,int *colstat)
 {  {
     int i,j,k,l,inv,a,rank,s;      int i,j,k,l,inv,a,rank,s;
Line 7666  void nd_det(int mod,MAT f,P *rp)
Line 8377  void nd_det(int mod,MAT f,P *rp)
     chsgnq(ONE,&mone);      chsgnq(ONE,&mone);
     for ( j = 0, sgn = 1; j < n; j++ ) {      for ( j = 0, sgn = 1; j < n; j++ ) {
         if ( DP_Print ) {          if ( DP_Print ) {
           fprintf(stderr,".",j);            fprintf(asir_out,".",j);
         }          }
         for ( i = j; i < n && !dm[i][j]; i++ );          for ( i = j; i < n && !dm[i][j]; i++ );
         if ( i == n ) {          if ( i == n ) {
Line 7696  void nd_det(int mod,MAT f,P *rp)
Line 8407  void nd_det(int mod,MAT f,P *rp)
             nd_det_reconstruct(dm,n,j,d);              nd_det_reconstruct(dm,n,j,d);
   
         for ( i = j+1, mj = dm[j], mjj = mj[j]; i < n; i++ ) {          for ( i = j+1, mj = dm[j], mjj = mj[j]; i < n; i++ ) {
 /*            if ( DP_Print ) fprintf(stderr,"    i=%d\n        ",i); */  /*            if ( DP_Print ) fprintf(asir_out,"    i=%d\n        ",i); */
             mi = dm[i]; mij = mi[j];              mi = dm[i]; mij = mi[j];
             if ( mod )              if ( mod )
                 ndv_mul_c(mod,mij,mod-1);                  ndv_mul_c(mod,mij,mod-1);
             else              else
                 ndv_mul_c_q(mij,mone);                  ndv_mul_c_q(mij,mone);
             for ( k = j+1; k < n; k++ ) {              for ( k = j+1; k < n; k++ ) {
 /*                if ( DP_Print ) fprintf(stderr,"k=%d ",k); */  /*                if ( DP_Print ) fprintf(asir_out,"k=%d ",k); */
                 bucket = create_pbucket();                  bucket = create_pbucket();
                 if ( mi[k] ) {                  if ( mi[k] ) {
                     nmv = BDY(mjj); len = LEN(mjj);                      nmv = BDY(mjj); len = LEN(mjj);
Line 7722  void nd_det(int mod,MAT f,P *rp)
Line 8433  void nd_det(int mod,MAT f,P *rp)
                 u = nd_quo(mod,bucket,d);                  u = nd_quo(mod,bucket,d);
                 mi[k] = ndtondv(mod,u);                  mi[k] = ndtondv(mod,u);
             }              }
 /*            if ( DP_Print ) fprintf(stderr,"\n",k); */  /*            if ( DP_Print ) fprintf(asir_out,"\n",k); */
         }          }
         d = mjj;          d = mjj;
     }      }
     if ( DP_Print ) {      if ( DP_Print ) {
       fprintf(stderr,"\n",k);        fprintf(asir_out,"\n",k);
     }      }
     if ( sgn < 0 )      if ( sgn < 0 )
         if ( mod )          if ( mod )
Line 7903  int nd_monic(int mod,ND *p)
Line 8614  int nd_monic(int mod,ND *p)
     is_lc = 1;      is_lc = 1;
     while ( 1 ) {      while ( 1 ) {
         NEWMP(mp0); mp = mp0;          NEWMP(mp0); mp = mp0;
         mp->c = (P)CQ(m);          mp->c = (Obj)CQ(m);
         mp->dl = nd_separate_d(DL(m),DL(ma));          mp->dl = nd_separate_d(DL(m),DL(ma));
         NEWNM(mb);          NEWNM(mb);
         for ( m = NEXT(m); m; m = NEXT(m) ) {          for ( m = NEXT(m); m; m = NEXT(m) ) {
             alg = nd_separate_d(DL(m),DL(mb));              alg = nd_separate_d(DL(m),DL(mb));
             if ( !ndl_equal(DL(ma),DL(mb)) )              if ( !ndl_equal(DL(ma),DL(mb)) )
                 break;                  break;
             NEXTMP(mp0,mp); mp->c = (P)CQ(m); mp->dl = alg;              NEXTMP(mp0,mp); mp->c = (Obj)CQ(m); mp->dl = alg;
         }          }
         NEXT(mp) = 0;          NEXT(mp) = 0;
         MKDP(nd_nalg,mp0,nm);          MKDP(nd_nalg,mp0,nm);
Line 7986  P ndc_div(int mod,union oNDC a,union oNDC b)
Line 8697  P ndc_div(int mod,union oNDC a,union oNDC b)
     int inv,t;      int inv,t;
   
     if ( mod == -1 ) c.m = _mulsf(a.m,_invsf(b.m));      if ( mod == -1 ) c.m = _mulsf(a.m,_invsf(b.m));
       else if ( mod == -2 ) divlf(a.z,b.z,&c.z);
     else if ( mod ) {      else if ( mod ) {
         inv = invm(b.m,mod);          inv = invm(b.m,mod);
         DMAR(a.m,inv,0,mod,t); c.m = t;          DMAR(a.m,inv,0,mod,t); c.m = t;
Line 8004  P ndctop(int mod,union oNDC c)
Line 8716  P ndctop(int mod,union oNDC c)
   
     if ( mod == -1 ) {      if ( mod == -1 ) {
         e = IFTOF(c.m); MKGFS(e,gfs); return (P)gfs;          e = IFTOF(c.m); MKGFS(e,gfs); return (P)gfs;
     } else if ( mod ) {      } else if ( mod > 0 ) {
         STOQ(c.m,q); return (P)q;          STOQ(c.m,q); return (P)q;
     } else      } else
         return (P)c.p;          return (P)c.p;
Line 8049  void conv_ilist(int demand,int trace,NODE g,int **indp
Line 8761  void conv_ilist(int demand,int trace,NODE g,int **indp
 void parse_nd_option(NODE opt)  void parse_nd_option(NODE opt)
 {  {
     NODE t,p,u;      NODE t,p,u;
         int i,s;          int i,s,n;
     char *key;      char *key;
     Obj value;      Obj value;
   
     nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0;      nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0;
         nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0;          nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0;
         nd_splist = 0; nd_check_splist = 0;          nd_splist = 0; nd_check_splist = 0;
       nd_sugarweight = 0;
       nd_f4red =0;
       nd_rank0 = 0;
     for ( t = opt; t; t = NEXT(t) ) {      for ( t = opt; t; t = NEXT(t) ) {
         p = BDY((LIST)BDY(t));          p = BDY((LIST)BDY(t));
         key = BDY((STRING)BDY(p));          key = BDY((STRING)BDY(p));
Line 8067  void parse_nd_option(NODE opt)
Line 8782  void parse_nd_option(NODE opt)
         else if ( !strcmp(key,"nora") )          else if ( !strcmp(key,"nora") )
             nd_nora = value?1:0;              nd_nora = value?1:0;
         else if ( !strcmp(key,"gbblock") ) {          else if ( !strcmp(key,"gbblock") ) {
                         if ( !value || OID(value) != O_LIST )              if ( value && OID(value) == O_LIST ) {
                                 error("nd_* : invalid value for gbblock option");                            u = BDY((LIST)value);
                         u = BDY((LIST)value);                nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int));
             nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int));                            for ( i = 0; u; u = NEXT(u) ) {
                         for ( i = 0; u; u = NEXT(u) ) {                                    p = BDY((LIST)BDY(u));
                                 p = BDY((LIST)BDY(u));                                    s = nd_gbblock[i++] = QTOS((Q)BDY(p));
                                 s = nd_gbblock[i++] = QTOS((Q)BDY(p));                                    nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1;
                                 nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1;                            }
                         }                            nd_gbblock[i] = -1;
                         nd_gbblock[i] = -1;              } else
                 nd_gbblock = 0;
                 } else if ( !strcmp(key,"newelim") )                  } else if ( !strcmp(key,"newelim") )
             nd_newelim = value?1:0;              nd_newelim = value?1:0;
                 else if ( !strcmp(key,"intersect") )                  else if ( !strcmp(key,"intersect") )
             nd_intersect = value?1:0;              nd_intersect = value?1:0;
                   else if ( !strcmp(key,"lf") )
               nd_lf = value?1:0;
                 else if ( !strcmp(key,"trace") ) {                  else if ( !strcmp(key,"trace") ) {
            u = BDY((LIST)value);             if ( value ) {
                    nd_nzlist = BDY((LIST)ARG2(u));                 u = BDY((LIST)value);
                    nd_bpe = QTOS((Q)ARG3(u));                         nd_nzlist = BDY((LIST)ARG2(u));
                 } else if ( !strcmp(key,"splist") )                         nd_bpe = QTOS((Q)ARG3(u));
              }
                   } else if ( !strcmp(key,"f4red") ) {
                      nd_f4red = QTOS((Q)value);
                   } else if ( !strcmp(key,"rank0") ) {
               nd_rank0 = value?1:0;
                   } else if ( !strcmp(key,"splist") ) {
             nd_splist = value?1:0;              nd_splist = value?1:0;
                 else if ( !strcmp(key,"check_splist") ) {                  } else if ( !strcmp(key,"check_splist") ) {
                         nd_check_splist = BDY((LIST)value);                          nd_check_splist = BDY((LIST)value);
                   } else if ( !strcmp(key,"sugarweight") ) {
                           u = BDY((LIST)value);
               n = length(u);
               nd_sugarweight = MALLOC(n*sizeof(int));
                           for ( i = 0; i < n; i++, u = NEXT(u) )
                   nd_sugarweight[i] = QTOS((Q)BDY(u));
                 }                  }
     }      }
 }  }
Line 8272  MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o
Line 9002  MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o
         printf("%d ",i); fflush(stdout);          printf("%d ",i); fflush(stdout);
     ti = BDY((LIST)BDY(t));      ti = BDY((LIST)BDY(t));
     p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);      p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);
     if ( j == 441 )  
                 printf("afo");  
   }    }
   for ( t = intred, i=0; t; t = NEXT(t), i++ ) {    for ( t = intred, i=0; t; t = NEXT(t), i++ ) {
         printf("%d ",i); fflush(stdout);          printf("%d ",i); fflush(stdout);
     ti = BDY((LIST)BDY(t));      ti = BDY((LIST)BDY(t));
     p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);      p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);
     if ( j == 441 )  
                 printf("afo");  
   }    }
   m = length(ind);    m = length(ind);
   MKMAT(mat,nb,m);    MKMAT(mat,nb,m);
Line 8371  VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp
Line 9097  VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp
   }    }
   return vect;    return vect;
 }  }
   
   void ndv_print_lf(NDV p)
   {
       NMV m;
       int i,len;
   
       if ( !p ) printf("0\n");
       else {
           len = LEN(p);
           for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) {
               printf("+");
               mpz_out_str(asir_out,10,BDY(CZ(m)));
               printf("*");
               ndl_print(DL(m));
           }
           printf("\n");
       }
   }
   
   void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp)
   {
       VL tv,fv,vv,vc,av;
       NODE fd,fd0,in0,in,r,r0,t,s,cand,alist;
       int m,nocheck,nvar,mindex,e,max;
       NDV c;
       NMV a;
       P p,zp;
       Q dmy;
       EPOS oepos;
       int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg,mrank,trank,ompos;
       Alg alpha,dp;
       P poly;
       LIST f1,f2,zpl;
       Obj obj;
       NumberField nf;
       struct order_spec *ord1;
       struct oEGT eg_check,eg0,eg1;
       NODE tr,tl1,tl2,tl3,tl4;
       LIST l1,l2,l3,l4,l5;
       int *perm;
       int j,ret;
       Q jq,bpe;
   
       nd_module = 0;
       parse_nd_option(current_option);
       get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);
       if ( nd_vc )
         error("nd_f4_lf_trace : computation over a rational function field is not implemented");
       for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
       switch ( ord->id ) {
           case 1:
               if ( ord->nv != nvar )
                   error("nd_f4_lf_trace : invalid order specification");
               break;
           default:
               break;
       }
   
       nd_ntrans = nvar;
       nd_nalg = 0;
   
       nocheck = 0;
       mindex = 0;
   
       /* do not use on-demand load/save */
       nd_demand = 0;
       m = trace > 1 ? trace : get_lprime(mindex);
       nd_init_ord(ord);
       mrank = 0;
       for ( t = BDY(f), max = 1; t; t = NEXT(t) )
           for ( tv = vv; tv; tv = NEXT(tv) ) {
               if ( nd_module ) {
                   s = BDY((LIST)BDY(t));
                   trank = length(s);
                   mrank = MAX(mrank,trank);
                   for ( ; s; s = NEXT(s) ) {
                       e = getdeg(tv->v,(P)BDY(s));
                       max = MAX(e,max);
                   }
               } else {
                   e = getdeg(tv->v,(P)BDY(t));
                   max = MAX(e,max);
               }
           }
       nd_setup_parameters(nvar,max);
       obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos;
       ishomo = 1;
       /* XXX */
       for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
           if ( nd_module ) {
               c = (pointer)pltondv(CO,vv,(LIST)BDY(t));
           } else {
               c = (pointer)ptondv(CO,vv,(P)BDY(t));
           }
           if ( ishomo )
               ishomo = ishomo && ndv_ishomo(c);
           if ( c ) {
               NEXTNODE(in0,in); BDY(in) = (pointer)c;
               NEXTNODE(fd0,fd); BDY(fd) = (pointer)ndv_dup(0,c);
           }
       }
       if ( in0 ) NEXT(in) = 0;
       if ( fd0 ) NEXT(fd) = 0;
       if ( !ishomo && homo ) {
           for ( t = in0, wmax = max; t; t = NEXT(t) ) {
               c = (NDV)BDY(t); len = LEN(c);
               for ( a = BDY(c), i = 0; i < len; i++, NMV_ADV(a) )
                   wmax = MAX(TD(DL(a)),wmax);
           }
           homogenize_order(ord,nvar,&ord1);
           nd_init_ord(ord1);
           nd_setup_parameters(nvar+1,wmax);
           for ( t = fd0; t; t = NEXT(t) )
               ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);
       }
       if ( MaxDeg > 0 ) nocheck = 1;
       ret = ndv_setup(-2,m,fd0,nd_gbblock?1:0,0);
       if ( ret )
         cand = nd_f4_lf_trace_main(m,&perm);
       if ( !ret || !cand ) {
          *rp = 0; return;
       }
       if ( !ishomo && homo ) {
         /* dehomogenization */
         for ( t = cand; t; t = NEXT(t) ) ndv_dehomogenize((NDV)BDY(t),ord);
         nd_init_ord(ord);
         nd_setup_parameters(nvar,0);
       }
       cand = ndv_reducebase(cand,perm);
       cand = ndv_reduceall(-2,cand);
       cbpe = nd_bpe;
       get_eg(&eg0);
       if ( ret = ndv_check_membership(-2,in0,obpe,oadv,oepos,cand) ) {
         /* gbcheck : cand is a GB of Id(cand) ? */
         ret = nd_f4(-2,0,0);
       }
           if ( !ret ) {
         /* failure */
         *rp = 0; return;
       }
       get_eg(&eg1); init_eg(&eg_check); add_eg(&eg_check,&eg0,&eg1);
       if ( DP_Print )
           fprintf(asir_out,"check=%.3fsec\n",eg_check.exectime+eg_check.gctime);
       /* dp->p */
       nd_bpe = cbpe;
       nd_setup_parameters(nd_nvar,0);
       for ( r = cand; r; r = NEXT(r) ) {
         if ( nd_module ) BDY(r) = ndvtopl(-2,CO,vv,BDY(r),mrank);
         else BDY(r) = (pointer)ndvtop(-2,CO,vv,BDY(r));
       }
       MKLIST(*rp,cand);
   }
   
   NODE nd_f4_lf_trace_main(int m,int **indp)
   {
       int i,nh,stat,index;
       NODE r,rm,g;
       ND_pairs d,l,l0,t;
       ND spol,red;
       NDV nf,redv,nfqv,nfv;
       NM s0,s;
       NODE rp0,srp0,nflist,nflist_lf;
       int nsp,nred,col,rank,len,k,j,a;
       UINT c;
       UINT **spmat;
       UINT *s0vect,*svect,*p,*v;
       int *colstat;
       IndArray *imat;
       int *rhead;
       int spcol,sprow;
       int sugar;
       PGeoBucket bucket;
       struct oEGT eg0,eg1,eg_f4;
   
       g = 0; d = 0;
       for ( i = 0; i < nd_psn; i++ ) {
           d = update_pairs(d,g,i,0);
           g = update_base(g,i);
       }
       while ( d ) {
           get_eg(&eg0);
           l = nd_minsugarp(d,&d);
           sugar = SG(l);
           if ( MaxDeg > 0 && sugar > MaxDeg ) break;
           bucket = create_pbucket();
           stat = nd_sp_f4(m,0,l,bucket);
           if ( !stat ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           if ( bucket->m < 0 ) continue;
           col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0);
           if ( !col ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);
           if ( DP_Print )
               fprintf(asir_out,"sugar=%d,symb=%.3fsec,",
                   sugar,eg_f4.exectime+eg_f4.gctime);
           nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);
           if ( !l0 ) continue;
           l = l0;
   
           /* over LF */
           bucket = create_pbucket();
           stat = nd_sp_f4(-2,1,l,bucket);
           if ( !stat ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           if ( bucket->m < 0 ) continue;
           col = nd_symbolic_preproc(bucket,1,&s0vect,&rp0);
           if ( !col ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           nflist_lf = nd_f4_red(-2,l,1,s0vect,col,rp0,0);
           /* adding new bases */
           for ( rm = nflist, r = nflist_lf; r && rm; rm = NEXT(rm), r = NEXT(r) ) {
               nfv = (NDV)BDY(rm);
               nfqv = (NDV)BDY(r);
               if ( DL_COMPARE(HDL(nfv),HDL(nfqv)) ) return 0;
               ndv_removecont(m,nfv);
               ndv_removecont(-2,nfqv);
               nh = ndv_newps(-2,nfv,nfqv,1);
               d = update_pairs(d,g,nh,0);
               g = update_base(g,nh);
           }
           if ( r || rm ) return 0;
       }
           conv_ilist(nd_demand,1,g,indp);
       return g;
   }
   

Legend:
Removed from v.1.224  
changed lines
  Added in v.1.244

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>