[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.172 and 1.229

version 1.172, 2009/02/15 03:07:41 version 1.229, 2016/11/17 05:33:20
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.171 2009/02/11 06:30:21 noro Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.228 2016/08/08 07:18:10 noro Exp $ */
   
 #include "nd.h"  #include "nd.h"
   
   struct oEGT eg_search;
   
 int diag_period = 6;  int diag_period = 6;
   int weight_check = 1;
 int (*ndl_compare_function)(UINT *a1,UINT *a2);  int (*ndl_compare_function)(UINT *a1,UINT *a2);
 int nd_dcomp;  int nd_dcomp;
   int nd_rref2;
 NM _nm_free_list;  NM _nm_free_list;
 ND _nd_free_list;  ND _nd_free_list;
 ND_pairs _ndp_free_list;  ND_pairs _ndp_free_list;
 NODE nd_hcf;  NODE nd_hcf;
   
   Obj nd_top_weight;
   
 static NODE nd_subst;  static NODE nd_subst;
 static VL nd_vc;  static VL nd_vc;
 static int nd_ntrans;  static int nd_ntrans;
Line 34  static UINT nd_mask[32];
Line 40  static UINT nd_mask[32];
 static UINT nd_mask0,nd_mask1;  static UINT nd_mask0,nd_mask1;
   
 static NDV *nd_ps;  static NDV *nd_ps;
   static NDV *nd_ps_gz;
 static NDV *nd_ps_trace;  static NDV *nd_ps_trace;
   static NDV *nd_ps_sym;
   static NDV *nd_ps_trace_sym;
 static RHist *nd_psh;  static RHist *nd_psh;
 static int nd_psn,nd_pslen;  static int nd_psn,nd_pslen;
 static RHist *nd_red;  static RHist *nd_red;
Line 46  static int nd_worb_len;
Line 55  static int nd_worb_len;
 static int nd_found,nd_create,nd_notfirst;  static int nd_found,nd_create,nd_notfirst;
 static int nmv_adv;  static int nmv_adv;
 static int nd_demand;  static int nd_demand;
 static int nd_module,nd_ispot,nd_mpos;  static int nd_module,nd_ispot,nd_mpos,nd_pot_nelim;
   static int nd_module_rank,nd_poly_weight_len;
   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;  static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect;
   static int *nd_gbblock;
   static NODE nd_nzlist,nd_check_splist;
   static int nd_splist;
   
 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 61  LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank);
Line 75  LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank);
 NDV pltondv(VL vl,VL dvl,LIST p);  NDV pltondv(VL vl,VL dvl,LIST p);
 void pltozpl(LIST l,Q *cont,LIST *pp);  void pltozpl(LIST l,Q *cont,LIST *pp);
 void ndl_max(UINT *d1,unsigned *d2,UINT *d);  void ndl_max(UINT *d1,unsigned *d2,UINT *d);
 pointer GC_malloc_atomic_ignore_off_page(int);  
 void nmtodp(int mod,NM m,DP *r);  void nmtodp(int mod,NM m,DP *r);
 NODE reverse_node(NODE n);  NODE reverse_node(NODE n);
 P ndc_div(int mod,union oNDC a,union oNDC b);  P ndc_div(int mod,union oNDC a,union oNDC b);
Line 69  P ndctop(int mod,union oNDC c);
Line 82  P ndctop(int mod,union oNDC c);
 void finalize_tracelist(int i,P cont);  void finalize_tracelist(int i,P cont);
 void conv_ilist(int demand,int trace,NODE g,int **indp);  void conv_ilist(int demand,int trace,NODE g,int **indp);
 void parse_nd_option(NODE opt);  void parse_nd_option(NODE opt);
   void dltondl(int n,DL dl,UINT *r);
   DP ndvtodp(int mod,NDV p);
   DP ndtodp(int mod,ND p);
   NDV ndvtondvgz(NDV p);
   NDV ndvgztondv(NDV p);
   ND ndtondgz(ND p);
   ND ndgztond(ND p);
   
 extern int Denominator,DP_Multiple;  void Pdp_set_weight(NODE,VECT *);
   void Pox_cmo_rpc(NODE,Obj *);
   
   extern int Denominator,DP_Multiple,MaxDeg;
   
   #define BLEN (8*sizeof(unsigned long))
   
   typedef struct matrix {
     int row,col;
     unsigned long **a;
   } *matrix;
   
   
 void nd_free_private_storage()  void nd_free_private_storage()
 {  {
     _nm_free_list = 0;      _nm_free_list = 0;
Line 87  void _NM_alloc()
Line 118  void _NM_alloc()
     int i;      int i;
   
     for ( i = 0; i < 1024; i++ ) {      for ( i = 0; i < 1024; i++ ) {
         p = (NM)GC_malloc(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));          p = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));
         p->next = _nm_free_list; _nm_free_list = p;          p->next = _nm_free_list; _nm_free_list = p;
     }      }
 }  }
   
   matrix alloc_matrix(int row,int col)
   {
     unsigned long **a;
     int i,len,blen;
     matrix mat;
   
     mat = (matrix)MALLOC(sizeof(struct matrix));
     mat->row = row;
     mat->col = col;
     mat->a = a = (unsigned long **)MALLOC(row*sizeof(unsigned long *));
     return mat;
   }
   
   
 void _ND_alloc()  void _ND_alloc()
 {  {
     ND p;      ND p;
     int i;      int i;
   
     for ( i = 0; i < 1024; i++ ) {      for ( i = 0; i < 1024; i++ ) {
         p = (ND)GC_malloc(sizeof(struct oND));          p = (ND)MALLOC(sizeof(struct oND));
         p->body = (NM)_nd_free_list; _nd_free_list = p;          p->body = (NM)_nd_free_list; _nd_free_list = p;
     }      }
 }  }
Line 109  void _NDP_alloc()
Line 154  void _NDP_alloc()
     int i;      int i;
   
     for ( i = 0; i < 1024; i++ ) {      for ( i = 0; i < 1024; i++ ) {
         p = (ND_pairs)GC_malloc(sizeof(struct oND_pairs)          p = (ND_pairs)MALLOC(sizeof(struct oND_pairs)
             +(nd_wpd-1)*sizeof(UINT));              +(nd_wpd-1)*sizeof(UINT));
         p->next = _ndp_free_list; _ndp_free_list = p;          p->next = _ndp_free_list; _ndp_free_list = p;
     }      }
Line 482  int ndl_block_compare(UINT *d1,UINT *d2)
Line 527  int ndl_block_compare(UINT *d1,UINT *d2)
   
 int ndl_matrix_compare(UINT *d1,UINT *d2)  int ndl_matrix_compare(UINT *d1,UINT *d2)
 {  {
     int i,j,s;      int i,j,s,row;
     int *v;      int *v;
           Q **mat;
       Q *w;
       Q t,t1,t2;
   
     for ( j = 0; j < nd_nvar; j++ )      for ( j = 0; j < nd_nvar; j++ )
         nd_work_vector[j] = GET_EXP(d1,j)-GET_EXP(d2,j);          nd_work_vector[j] = GET_EXP(d1,j)-GET_EXP(d2,j);
           if ( nd_top_weight ) {
                   if ( OID(nd_top_weight) == O_VECT ) {
                       mat = (Q **)&BDY((VECT)nd_top_weight);
                       row = 1;
                   } else {
                           mat = (Q **)BDY((MAT)nd_top_weight);
                       row = ((MAT)nd_top_weight)->row;
                   }
                   for ( i = 0; i < row; i++ ) {
                       w = (Q *)mat[i];
                           for ( j = 0, t = 0; j < nd_nvar; j++ ) {
                                   STOQ(nd_work_vector[j],t1);
                               mulq(w[j],t1,&t2);
                                   addq(t,t2,&t1);
                                   t = t1;
                           }
                       if ( t ) {
                           s = SGN(t);
                           if ( s > 0 ) return 1;
                           else if ( s < 0 ) return -1;
                       }
                   }
           }
     for ( i = 0; i < nd_matrix_len; i++ ) {      for ( i = 0; i < nd_matrix_len; i++ ) {
         v = nd_matrix[i];          v = nd_matrix[i];
         for ( j = 0, s = 0; j < nd_nvar; j++ )          for ( j = 0, s = 0; j < nd_nvar; j++ )
Line 494  int ndl_matrix_compare(UINT *d1,UINT *d2)
Line 565  int ndl_matrix_compare(UINT *d1,UINT *d2)
         if ( s > 0 ) return 1;          if ( s > 0 ) return 1;
         else if ( s < 0 ) return -1;          else if ( s < 0 ) return -1;
     }      }
           if ( !ndl_equal(d1,d2) )
                   error("afo");
     return 0;      return 0;
 }  }
   
Line 576  int ndl_ww_lex_compare(UINT *d1,UINT *d2)
Line 649  int ndl_ww_lex_compare(UINT *d1,UINT *d2)
     return ndl_lex_compare(d1,d2);      return ndl_lex_compare(d1,d2);
 }  }
   
   int ndl_module_weight_compare(UINT *d1,UINT *d2)
   {
     int s,j;
   
     if ( nd_nvar != nd_poly_weight_len )
       error("invalid module weight : the length of polynomial weight != the number of variables");
     s = 0;
     for ( j = 0; j < nd_nvar; j++ )
        s += (GET_EXP(d1,j)-GET_EXP(d2,j))*nd_poly_weight[j];
     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;
     else if ( s < 0 ) return -1;
     else return 0;
   }
   
 int ndl_module_grlex_compare(UINT *d1,UINT *d2)  int ndl_module_grlex_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,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 ( TD(d1) > TD(d2) ) return 1;
               else if ( TD(d1) < TD(d2) ) return -1;
               if ( c = ndl_lex_compare(d1,d2) ) return c;
               if ( MPOS(d1) < MPOS(d2) ) return 1;
               else if ( MPOS(d1) > MPOS(d2) ) return -1;
               return 0;
                   }
         if ( MPOS(d1) < MPOS(d2) ) return 1;          if ( MPOS(d1) < MPOS(d2) ) return 1;
         else if ( MPOS(d1) > MPOS(d2) ) return -1;          else if ( MPOS(d1) > MPOS(d2) ) return -1;
     }      }
Line 598  int ndl_module_glex_compare(UINT *d1,UINT *d2)
Line 697  int ndl_module_glex_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
       if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
         if ( MPOS(d1) < MPOS(d2) ) return 1;          if ( MPOS(d1) < MPOS(d2) ) return 1;
         else if ( MPOS(d1) > MPOS(d2) ) return -1;          else if ( MPOS(d1) > MPOS(d2) ) return -1;
Line 616  int ndl_module_lex_compare(UINT *d1,UINT *d2)
Line 716  int ndl_module_lex_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
       if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
         if ( MPOS(d1) < MPOS(d2) ) return 1;          if ( MPOS(d1) < MPOS(d2) ) return 1;
         else if ( MPOS(d1) > MPOS(d2) ) return -1;          else if ( MPOS(d1) > MPOS(d2) ) return -1;
Line 632  int ndl_module_block_compare(UINT *d1,UINT *d2)
Line 733  int ndl_module_block_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
       if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
         if ( MPOS(d1) < MPOS(d2) ) return 1;          if ( MPOS(d1) < MPOS(d2) ) return 1;
         else if ( MPOS(d1) > MPOS(d2) ) return -1;          else if ( MPOS(d1) > MPOS(d2) ) return -1;
Line 648  int ndl_module_matrix_compare(UINT *d1,UINT *d2)
Line 750  int ndl_module_matrix_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
       if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
         if ( MPOS(d1) < MPOS(d2) ) return 1;          if ( MPOS(d1) < MPOS(d2) ) return 1;
         else if ( MPOS(d1) > MPOS(d2) ) return -1;          else if ( MPOS(d1) > MPOS(d2) ) return -1;
Line 664  int ndl_module_composite_compare(UINT *d1,UINT *d2)
Line 767  int ndl_module_composite_compare(UINT *d1,UINT *d2)
 {  {
     int i,c;      int i,c;
   
       if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c;
     if ( nd_ispot ) {      if ( nd_ispot ) {
         if ( MPOS(d1) > MPOS(d2) ) return 1;          if ( MPOS(d1) > MPOS(d2) ) return 1;
         else if ( MPOS(d1) < MPOS(d2) ) return -1;          else if ( MPOS(d1) < MPOS(d2) ) return -1;
Line 1334  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
Line 1438  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
                 node = mknode(4,div,iq,dmul,ONE);                  node = mknode(4,div,iq,dmul,ONE);
             }              }
             sugar = MAX(sugar,SG(p)+TD(DL(mul)));              sugar = MAX(sugar,SG(p)+TD(DL(mul)));
             if ( !mod && g && ((double)(p_mag(HCP(g))) > hmag) ) {              if ( !mod && g && !nd_vc && ((double)(p_mag(HCP(g))) > hmag) ) {
                 hg = HCU(g);                  hg = HCU(g);
                 nd_removecont2(d,g);                  nd_removecont2(d,g);
                 if ( dn || nd_gentrace ) {                  if ( dn || nd_gentrace ) {
Line 1568  void free_pbucket(PGeoBucket b) {
Line 1672  void free_pbucket(PGeoBucket b) {
             nd_free(b->body[i]);              nd_free(b->body[i]);
             b->body[i] = 0;              b->body[i] = 0;
         }          }
     GC_free(b);      GCFREE(b);
 }  }
   
 void add_pbucket_symbolic(PGeoBucket g,ND d)  void add_pbucket_symbolic(PGeoBucket g,ND d)
Line 1853  int do_diagonalize(int sugar,int m)
Line 1957  int do_diagonalize(int sugar,int m)
     return 1;      return 1;
 }  }
   
   LIST compute_splist()
   {
           NODE g,tn0,tn,node;
           LIST l0;
           ND_pairs d,t;
           int i;
           Q i1,i2;
   
       g = 0; d = 0;
       for ( i = 0; i < nd_psn; i++ ) {
           d = update_pairs(d,g,i,0);
           g = update_base(g,i);
       }
           for ( t = d, tn0 = 0; t; t = NEXT(t) ) {
                   NEXTNODE(tn0,tn);
           STOQ(t->i1,i1); STOQ(t->i2,i2);
           node = mknode(2,i1,i2); MKLIST(l0,node);
                   BDY(tn) = l0;
           }
           if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0);
           return l0;
   }
   
 /* return value = 0 => input is not a GB */  /* return value = 0 => input is not a GB */
   
 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,int **indp)  NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,int **indp)
Line 1878  NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i
Line 2005  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 1909  again:
Line 2037  again:
             goto again;              goto again;
         } else if ( nf ) {          } else if ( nf ) {
             if ( checkonly || gensyz ) return 0;              if ( checkonly || gensyz ) return 0;
                           if ( nd_newelim ) {
                                   if ( nd_module ) {
                                           if ( MPOS(HDL(nf)) > 1 ) return 0;
                                   } else if ( !(HDL(nf)[nd_exporigin] & nd_mask[0]) ) return 0;
                           }
             if ( DP_Print ) { printf("+"); fflush(stdout); }              if ( DP_Print ) { printf("+"); fflush(stdout); }
             hc = HCU(nf);              hc = HCU(nf);
             nd_removecont(m,nf);              nd_removecont(m,nf);
Line 1919  again:
Line 2052  again:
             if ( nd_gentrace ) {              if ( nd_gentrace ) {
                                 cont = ndc_div(m,hc,HCU(nf));                                  cont = ndc_div(m,hc,HCU(nf));
                                 if ( m || !UNIQ(cont) ) {                                  if ( m || !UNIQ(cont) ) {
                     t = mknode(4,0,0,0,cont);                      t = mknode(4,NULLP,NULLP,NULLP,cont);
                     MKLIST(list,t); MKNODE(t,list,nd_tracelist);                      MKLIST(list,t); MKNODE(t,list,nd_tracelist);
                                         nd_tracelist = t;                                          nd_tracelist = t;
                                 }                                  }
             }              }
             nfv = ndtondv(m,nf); nd_free(nf);              nfv = ndtondv(m,nf); nd_free(nf);
             nh = ndv_newps(m,nfv,0);              nh = ndv_newps(m,nfv,0,0);
             if ( !m && (ishomo && ++diag_count == diag_period) ) {              if ( !m && (ishomo && ++diag_count == diag_period) ) {
                 diag_count = 0;                  diag_count = 0;
                 stat = do_diagonalize(sugar,m);                  stat = do_diagonalize(sugar,m);
Line 1955  again:
Line 2088  again:
     return g;      return g;
 }  }
   
   /* splist = [[i1,i2],...] */
   
   int check_splist(int m,NODE splist)
   {
           NODE t,p;
           ND_pairs d,r,l;
           int stat;
           ND h,nf;
   
           for ( d = 0, t = splist; t; t = NEXT(t) ) {
                   p = BDY((LIST)BDY(t));
           NEXTND_pairs(d,r);
           r->i1 = QTOS((Q)ARG0(p)); r->i2 = QTOS((Q)ARG1(p));
           ndl_lcm(DL(nd_psh[r->i1]),DL(nd_psh[r->i2]),r->lcm);
                   SG(r) = TD(LCM(r)); /* XXX */
           }
           if ( d ) NEXT(r) = 0;
   
       while ( d ) {
   again:
           l = nd_minp(d,&d);
           stat = nd_sp(m,0,l,&h);
           if ( !stat ) {
               NEXT(l) = d; d = l;
               d = nd_reconstruct(0,d);
               goto again;
           }
           stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf);
           if ( !stat ) {
               NEXT(l) = d; d = l;
               d = nd_reconstruct(0,d);
               goto again;
           } else if ( nf ) return 0;
                   if ( DP_Print) { printf("."); fflush(stdout); }
       }
           if ( DP_Print) { printf("done.\n"); fflush(stdout); }
           return 1;
   }
   
   int check_splist_f4(int m,NODE splist)
   {
           UINT *s0vect;
       PGeoBucket bucket;
           NODE p,rp0,t;
           ND_pairs d,r,l,ll;
           int col,stat;
   
           for ( d = 0, t = splist; t; t = NEXT(t) ) {
                   p = BDY((LIST)BDY(t));
           NEXTND_pairs(d,r);
           r->i1 = QTOS((Q)ARG0(p)); r->i2 = QTOS((Q)ARG1(p));
           ndl_lcm(DL(nd_psh[r->i1]),DL(nd_psh[r->i2]),r->lcm);
                   SG(r) = TD(LCM(r)); /* XXX */
           }
           if ( d ) NEXT(r) = 0;
   
       while ( d ) {
           l = nd_minsugarp(d,&d);
           bucket = create_pbucket();
           stat = nd_sp_f4(m,0,l,bucket);
           if ( !stat ) {
               for ( ll = l; NEXT(ll); ll = NEXT(ll) );
               NEXT(ll) = d; d = l;
               d = nd_reconstruct(0,d);
               continue;
           }
           if ( bucket->m < 0 ) continue;
           col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0);
           if ( !col ) {
               for ( ll = l; NEXT(ll); ll = NEXT(ll) );
               NEXT(ll) = d; d = l;
               d = nd_reconstruct(0,d);
               continue;
           }
           if ( nd_f4_red(m,l,0,s0vect,col,rp0,0) ) return 0;
       }
       return 1;
   }
   
 int do_diagonalize_trace(int sugar,int m)  int do_diagonalize_trace(int sugar,int m)
 {  {
     int i,nh,stat;      int i,nh,stat;
Line 2052  NODE nd_gb_trace(int m,int ishomo,int **indp)
Line 2264  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 2121  again:
Line 2334  again:
                 if ( nd_gentrace ) {                  if ( nd_gentrace ) {
                                    cont = ndc_div(0,hnfq,HCU(nfqv));                                     cont = ndc_div(0,hnfq,HCU(nfqv));
                                    if ( !UNIQ(cont) ) {                                     if ( !UNIQ(cont) ) {
                        t = mknode(4,0,0,0,cont);                         t = mknode(4,NULLP,NULLP,NULLP,cont);
                        MKLIST(list,t); MKNODE(t,list,nd_tracelist);                         MKLIST(list,t); MKNODE(t,list,nd_tracelist);
                                            nd_tracelist = t;                                             nd_tracelist = t;
                                    }                                     }
                 }                  }
                 nh = ndv_newps(0,nfv,nfqv);                  nh = ndv_newps(0,nfv,nfqv,0);
                 if ( ishomo && ++diag_count == diag_period ) {                  if ( ishomo && ++diag_count == diag_period ) {
                     diag_count = 0;                      diag_count = 0;
                     if ( DP_Print > 2 ) fprintf(asir_out,"|");                      if ( DP_Print > 2 ) fprintf(asir_out,"|");
Line 2149  again:
Line 2362  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 2192  NODE ndv_reduceall(int m,NODE f)
Line 2407  NODE ndv_reduceall(int m,NODE f)
     union oNDC hc;      union oNDC hc;
     P cont,cont1;      P cont,cont1;
   
       if ( nd_nora ) return f;
     n = length(f);      n = length(f);
     ndv_setup(m,0,f,0,1);      ndv_setup(m,0,f,0,1);
         perm = (int *)MALLOC(n*sizeof(int));          perm = (int *)MALLOC(n*sizeof(int));
Line 2291  ND_pairs nd_newpairs( NODE g, int t )
Line 2507  ND_pairs nd_newpairs( NODE g, int t )
 {  {
     NODE h;      NODE h;
     UINT *dl;      UINT *dl;
     int ts,s;      int ts,s,i,t0,min,max;
     ND_pairs r,r0;      ND_pairs r,r0;
   
     dl = DL(nd_psh[t]);      dl = DL(nd_psh[t]);
     ts = SG(nd_psh[t]) - TD(dl);      ts = SG(nd_psh[t]) - TD(dl);
           if ( nd_module && nd_intersect && (MPOS(dl) > 1) ) return 0;
     for ( r0 = 0, h = g; h; h = NEXT(h) ) {      for ( r0 = 0, h = g; h; h = NEXT(h) ) {
         if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) )          if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) )
                 continue;                  continue;
                   if ( nd_gbblock ) {
                           t0 = (long)BDY(h);
                           for ( i = 0; nd_gbblock[i] >= 0; i += 2 ) {
                                   min = nd_gbblock[i]; max = nd_gbblock[i+1];
                                   if ( t0 >= min && t0 <= max && t >= min && t <= max )
                                           break;
                           }
                           if ( nd_gbblock[i] >= 0 )
                                   continue;
                   }
         NEXTND_pairs(r0,r);          NEXTND_pairs(r0,r);
         r->i1 = (long)BDY(h);          r->i1 = (long)BDY(h);
         r->i2 = t;          r->i2 = t;
Line 2537  ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )
Line 2764  ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )
     return dm0;      return dm0;
 }  }
   
 int ndv_newps(int m,NDV a,NDV aq)  int ndv_newps(int m,NDV a,NDV aq,int f4)
 {  {
     int len;      int len;
     RHist r;      RHist r;
Line 2549  int ndv_newps(int m,NDV a,NDV aq)
Line 2776  int ndv_newps(int m,NDV a,NDV aq)
     if ( nd_psn == nd_pslen ) {      if ( nd_psn == nd_pslen ) {
         nd_pslen *= 2;          nd_pslen *= 2;
         nd_ps = (NDV *)REALLOC((char *)nd_ps,nd_pslen*sizeof(NDV));          nd_ps = (NDV *)REALLOC((char *)nd_ps,nd_pslen*sizeof(NDV));
           nd_ps_gz = (NDV *)REALLOC((char *)nd_ps_gz,nd_pslen*sizeof(NDV));
         nd_ps_trace = (NDV *)REALLOC((char *)nd_ps_trace,nd_pslen*sizeof(NDV));          nd_ps_trace = (NDV *)REALLOC((char *)nd_ps_trace,nd_pslen*sizeof(NDV));
         nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist));          nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist));
         nd_bound = (UINT **)          nd_bound = (UINT **)
             REALLOC((char *)nd_bound,nd_pslen*sizeof(UINT *));              REALLOC((char *)nd_bound,nd_pslen*sizeof(UINT *));
           nd_ps_sym = (NDV *)REALLOC((char *)nd_ps_sym,nd_pslen*sizeof(NDV));
           nd_ps_trace_sym = (NDV *)REALLOC((char *)nd_ps_trace_sym,nd_pslen*sizeof(NDV));
     }      }
     NEWRHist(r); nd_psh[nd_psn] = r;      NEWRHist(r); nd_psh[nd_psn] = r;
     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);
         register_hcf(aq);          register_hcf(aq);
         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));          SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r));
Line 2565  int ndv_newps(int m,NDV a,NDV aq)
Line 2796  int ndv_newps(int m,NDV a,NDV aq)
         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));          SG(r) = SG(a); ndl_copy(HDL(a),DL(r));
                   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_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 {
             ndv_save(nd_ps[nd_psn],nd_psn);              ndv_save(nd_ps[nd_psn],nd_psn);
               nd_ps_sym[nd_psn] = ndv_symbolic(m,nd_ps[nd_psn]);
             nd_ps[nd_psn] = 0;              nd_ps[nd_psn] = 0;
         }          }
     }      }
Line 2585  int ndv_newps(int m,NDV a,NDV aq)
Line 2819  int ndv_newps(int m,NDV a,NDV aq)
 }  }
   
 /* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */  /* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */
   /* return 1 if success, 0 if failure (HC(a mod p)) */
   
 void ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont)  int ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont)
 {  {
     int i,j,td,len,max;      int i,j,td,len,max;
     NODE s,s0,f0,tn;      NODE s,s0,f0,tn;
Line 2619  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
Line 2854  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
     }      }
     nd_pslen = 2*nd_psn;      nd_pslen = 2*nd_psn;
     nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));      nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
       nd_ps_gz = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
     nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));      nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
       nd_ps_sym = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
       nd_ps_trace_sym = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
     nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));      nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));
     nd_bound = (UINT **)MALLOC(nd_pslen*sizeof(UINT *));      nd_bound = (UINT **)MALLOC(nd_pslen*sizeof(UINT *));
     nd_hcf = 0;      nd_hcf = 0;
Line 2636  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
Line 2874  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
         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);              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);              if ( !dont_removecont) ndv_removecont(0,a);
             register_hcf(a);              register_hcf(a);
             am = nd_ps[i] = ndv_dup(mod,a);              am = nd_ps[i] = ndv_dup(mod,a);
             ndv_mod(mod,am);              ndv_mod(mod,am);
                   if ( DL_COMPARE(HDL(am),HDL(a)) )
                       return 0;
             ndv_removecont(mod,am);              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 || !dont_removecont ) ndv_removecont(mod,a);              if ( mod || !dont_removecont ) ndv_removecont(mod,a);
             if ( !mod ) register_hcf(a);              if ( !mod ) register_hcf(a);
         }          }
Line 2658  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
Line 2900  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
         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_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);
                 nd_ps_trace[i] = 0;                  nd_ps_trace[i] = 0;
             } else {              } else {
                 ndv_save(nd_ps[i],i);                  ndv_save(nd_ps[i],i);
                   nd_ps_sym[i] = ndv_symbolic(mod,nd_ps[i]);
                 nd_ps[i] = 0;                  nd_ps[i] = 0;
             }              }
         }          }
     }      }
     if ( nd_gentrace && nd_tracelist ) NEXT(tn) = 0;      if ( nd_gentrace && nd_tracelist ) NEXT(tn) = 0;
       return 1;
 }  }
   
 struct order_spec *append_block(struct order_spec *spec,  struct order_spec *append_block(struct order_spec *spec,
Line 2773  NODE postprocess_algcoef(VL av,NODE alist,NODE r)
Line 3018  NODE postprocess_algcoef(VL av,NODE alist,NODE r)
     return u0;      return u0;
 }  }
   
 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spec *ord,LIST *rp)  void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int f4,struct order_spec *ord,LIST *rp)
 {  {
     VL tv,fv,vv,vc,av;      VL tv,fv,vv,vc,av;
     NODE fd,fd0,r,r0,t,x,s,xx,alist;      NODE fd,fd0,r,r0,t,x,s,xx,alist;
     int e,max,nvar,i;      int e,max,nvar,i;
     NDV b;      NDV b;
     int ishomo,nalg,mrank,trank;      int ishomo,nalg,mrank,trank,wmax,len;
           NMV a;
     Alg alpha,dp;      Alg alpha,dp;
     P p,zp;      P p,zp;
     Q dmy;      Q dmy;
Line 2787  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 3033  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
     Obj obj;      Obj obj;
     NumberField nf;      NumberField nf;
     struct order_spec *ord1;      struct order_spec *ord1;
     NODE tr,tl1,tl2,tl3,tl4;      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;          Q jq,bpe;
     int *perm;      int *perm;
     EPOS oepos;      EPOS oepos;
     int obpe,oadv,ompos;      int obpe,oadv,ompos,cbpe;
   
     nd_module;      nd_module = 0;
     if ( !m && Demand ) nd_demand = 1;      if ( !m && Demand ) nd_demand = 1;
     else nd_demand = 0;      else nd_demand = 0;
     parse_nd_option(current_option);      parse_nd_option(current_option);
Line 2806  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 3052  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
     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 2832  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 3080  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
     }      }
     nd_init_ord(ord);      nd_init_ord(ord);
     mrank = 0;      mrank = 0;
     for ( t = BDY(f), max = 0; t; t = NEXT(t) )      for ( t = BDY(f), max = 1; t; t = NEXT(t) )
         for ( tv = vv; tv; tv = NEXT(tv) ) {          for ( tv = vv; tv; tv = NEXT(tv) ) {
             if ( nd_module ) {              if ( nd_module ) {
                 s = BDY((LIST)BDY(t));                  s = BDY((LIST)BDY(t));
Line 2847  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 3095  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
                 max = MAX(e,max);                  max = MAX(e,max);
             }              }
         }          }
     nd_setup_parameters(nvar,max);      nd_setup_parameters(nvar,nd_nzlist?0:max);
     obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos;      obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos;
     ishomo = 1;      ishomo = 1;
     for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {      for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
Line 2866  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 3114  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
         if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; }          if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; }
     }      }
     if ( fd0 ) NEXT(fd) = 0;      if ( fd0 ) NEXT(fd) = 0;
     ndv_setup(m,0,fd0,0,0);  
           if ( !ishomo && homo ) {
           for ( t = fd0, wmax = max; t; t = NEXT(t) ) {
               b = (NDV)BDY(t); len = LEN(b);
               for ( a = BDY(b), 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);
       }
   
       ndv_setup(m,0,fd0,(nd_gbblock||nd_splist||nd_check_splist)?1:0,0);
     if ( nd_gentrace ) {      if ( nd_gentrace ) {
         MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);          MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);
     }      }
     x = f4?nd_f4(m,&perm):nd_gb(m,ishomo,0,0,&perm);          if ( nd_splist ) {
                   *rp = compute_splist();
                   return;
           }
           if ( nd_check_splist ) {
           if ( f4 ) {
               if ( check_splist_f4(m,nd_check_splist) ) *rp = (LIST)ONE;
               else *rp = 0;
           } else {
               if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE;
               else *rp = 0;
           }
                   return;
           }
       x = f4?nd_f4(m,&perm):nd_gb(m,ishomo || homo,0,0,&perm);
           if ( !x ) {
                   *rp = 0; return;
           }
           if ( !ishomo && homo ) {
                   /* dehomogenization */
                   for ( t = x; t; t = NEXT(t) ) ndv_dehomogenize((NDV)BDY(t),ord);
                   nd_init_ord(ord);
                   nd_setup_parameters(nvar,0);
           }
     nd_demand = 0;      nd_demand = 0;
           if ( nd_module && nd_intersect ) {
                   for ( j = nd_psn-1, x = 0; j >= 0; j-- )
                           if ( MPOS(DL(nd_psh[j])) > 1 ) {
                                   MKNODE(xx,(pointer)j,x); x = xx;
                           }
             conv_ilist(nd_demand,0,x,0);
             goto FINAL;
           }
       if ( nd_gentrace  && f4 ) { nzlist = nd_alltracelist; }
     x = ndv_reducebase(x,perm);      x = ndv_reducebase(x,perm);
     if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }      if ( nd_gentrace  && !f4 ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }
     x = ndv_reduceall(m,x);      x = ndv_reduceall(m,x);
     if ( nd_gentrace ) {      cbpe = nd_bpe;
       if ( nd_gentrace && !f4 ) {
         tl2 = nd_alltracelist; nd_alltracelist = 0;          tl2 = nd_alltracelist; nd_alltracelist = 0;
         ndv_check_membership(m,fd0,obpe,oadv,oepos,x);          ndv_check_membership(m,fd0,obpe,oadv,oepos,x);
         if ( nd_gentrace ) {          tl3 = nd_alltracelist; nd_alltracelist = 0;
             tl3 = nd_alltracelist; nd_alltracelist = 0;          if ( nd_gensyz ) {
         } else tl3 = 0;                  nd_gb(m,0,1,1,0);
         nd_gb(m,0,1,nd_gensyz?1:0,0)!=0;  
         if ( nd_gentrace && nd_gensyz ) {  
             tl4 = nd_alltracelist; nd_alltracelist = 0;              tl4 = nd_alltracelist; nd_alltracelist = 0;
         } else tl4 = 0;          } else tl4 = 0;
     }      }
       nd_bpe = cbpe;
       nd_setup_parameters(nd_nvar,0);
   FINAL:
     for ( r0 = 0, t = x; t; t = NEXT(t) ) {      for ( r0 = 0, t = x; t; t = NEXT(t) ) {
         NEXTNODE(r0,r);          NEXTNODE(r0,r);
     if ( nd_module ) BDY(r) = ndvtopl(m,CO,vv,BDY(t),mrank);          if ( nd_module ) BDY(r) = ndvtopl(m,CO,vv,BDY(t),mrank);
         else BDY(r) = ndvtop(m,CO,vv,BDY(t));          else if ( retdp ) BDY(r) = ndvtodp(m,BDY(t));
                   else BDY(r) = ndvtop(m,CO,vv,BDY(t));
     }      }
     if ( r0 ) NEXT(r) = 0;      if ( r0 ) NEXT(r) = 0;
     if ( nalg )      if ( !m && nd_nalg )
         r0 = postprocess_algcoef(av,alist,r0);          r0 = postprocess_algcoef(av,alist,r0);
     MKLIST(*rp,r0);      MKLIST(*rp,r0);
     if ( nd_gentrace ) {      if ( nd_gentrace ) {
         tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);          if ( f4 ) {
         tl3 = reverse_node(tl3);              STOQ(16,bpe);
                 /* tl2 = [[i,[[*,j,*,*],...]],...] */              tr = mknode(4,*rp,(!ishomo&&homo)?ONE:0,BDY(nzlist),bpe); MKLIST(*rp,tr);
         for ( t = tl2; t; t = NEXT(t) ) {          } else {
                         /* s = [i,[*,j,*,*],...] */              tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);
             s = BDY((LIST)BDY(t));              tl3 = reverse_node(tl3);
             j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq;              /* tl2 = [[i,[[*,j,*,*],...]],...] */
                         for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) {              for ( t = tl2; t; t = NEXT(t) ) {
                 j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq);              /* s = [i,[*,j,*,*],...] */
                                 ARG1(BDY((LIST)BDY(s))) = (pointer)jq;                  s = BDY((LIST)BDY(t));
                   j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq;
                   for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) {
                       j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq);
                       ARG1(BDY((LIST)BDY(s))) = (pointer)jq;
                   }
             }              }
                 }              for ( j = length(x)-1, t = 0; j >= 0; j-- ) {
                 for ( j = length(x)-1, t = 0; j >= 0; j-- ) {                  STOQ(perm[j],jq); MKNODE(s,jq,t); t = s;
                     STOQ(perm[j],jq); MKNODE(s,jq,t); t = s;              }
                 }              MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);
        MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);              MKLIST(l5,tl4);
        MKLIST(l5,tl4);              STOQ(nd_bpe,bpe);
       tr = mknode(7,*rp,0,l1,l2,l3,l4,l5); MKLIST(*rp,tr);              tr = mknode(8,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5,bpe); MKLIST(*rp,tr);
           }
     }      }
 #if 0  #if 0
     fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);      fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);
Line 2936  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3239  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
     struct order_spec *ord1;      struct order_spec *ord1;
     int *perm;      int *perm;
   
       parse_nd_option(current_option);
     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);
     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 ) {
Line 2962  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3266  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
         nvar += nalg;          nvar += nalg;
     }      }
     nd_init_ord(ord);      nd_init_ord(ord);
     for ( t = BDY(f), max = 0; t; t = NEXT(t) )      for ( t = BDY(f), max = 1; t; t = NEXT(t) )
         for ( tv = vv; tv; tv = NEXT(tv) ) {          for ( tv = vv; tv; tv = NEXT(tv) ) {
             e = getdeg(tv->v,(P)BDY(t));              e = getdeg(tv->v,(P)BDY(t));
             max = MAX(e,max);              max = MAX(e,max);
Line 2988  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3292  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
             return;              return;
         }          }
     } else {      } else {
   #if 0
                   /* bug ? */
         for ( t = x; t; t = NEXT(t) )          for ( t = x; t; t = NEXT(t) )
             BDY(t) = (pointer)nd_ps[(long)BDY(t)];              BDY(t) = (pointer)nd_ps[(long)BDY(t)];
   #else
                   conv_ilist(0,0,x,&perm);
   #endif
     }      }
     x = ndv_reducebase(x,perm);      x = ndv_reducebase(x,perm);
     x = ndv_reduceall(m,x);      x = ndv_reduceall(m,x);
Line 2998  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3307  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
         BDY(r) = ndvtop(m,CO,vv,BDY(t));          BDY(r) = ndvtop(m,CO,vv,BDY(t));
     }      }
     if ( r0 ) NEXT(r) = 0;      if ( r0 ) NEXT(r) = 0;
     if ( nalg )      if ( !m && nd_nalg )
         r0 = postprocess_algcoef(av,alist,r0);          r0 = postprocess_algcoef(av,alist,r0);
     MKLIST(*rp,r0);      MKLIST(*rp,r0);
 }  }
   
   NDV recompute_trace(NODE trace,NDV *p,int m);
   void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp);
   
   NDV recompute_trace(NODE ti,NDV *p,int mod)
   {
           int c,c1,c2,i;
           NM mul,m,tail;
           ND d,r,rm;
           NODE sj;
           NDV red;
           Obj mj;
           static int afo=0;
   
           afo++;
           mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT));
           CM(mul) = 1;
           tail = 0;
           for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) {
                   sj = BDY((LIST)BDY(ti));
                   if ( ARG0(sj) ) {
                           red = p[QTOS((Q)ARG1(sj))];
                           mj = (Obj)ARG2(sj);
                           if ( OID(mj) != O_DP ) ndl_zero(DL(mul));
                           else dltondl(nd_nvar,BDY((DP)mj)->dl,DL(mul));
                           rm = ndv_mul_nm(mod,mul,red);
                           if ( !r ) r = rm;
                           else {
                                   for ( m = BDY(r); m && !ndl_equal(m->dl,BDY(rm)->dl); m = NEXT(m), LEN(r)-- ) {
                                           if ( d ) {
                                                   NEXT(tail) = m; tail = m; LEN(d)++;
                                           } else {
                                                   MKND(nd_nvar,m,1,d); tail = BDY(d);
                                           }
                                   }
                                   if ( !m ) return 0; /* failure */
                                   else {
                                           BDY(r) = m;
                                           c1 = invm(HCM(rm),mod); c2 = mod-HCM(r);
                                           DMAR(c1,c2,0,mod,c);
                                           nd_mul_c(mod,rm,c);
                                           r = nd_add(mod,r,rm);
                                   }
                           }
                   }
           }
           if ( tail ) NEXT(tail) = 0;
           d = nd_add(mod,d,r);
           nd_mul_c(mod,d,invm(HCM(d),mod));
           return ndtondv(mod,d);
   }
   
   void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp)
   {
       VL tv,fv,vv,vc,av;
       NODE fd,fd0,r,r0,t,x,s,xx,alist;
       int e,max,nvar,i;
       NDV b;
       int ishomo,nalg;
       Alg alpha,dp;
       P p,zp;
       Q dmy;
       LIST f1,f2;
       Obj obj;
       NumberField nf;
       struct order_spec *ord1;
           NODE permtrace,intred,ind,perm,trace,ti;
           int len,n,j;
           NDV *db,*pb;
   
       parse_nd_option(current_option);
       get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);
       for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
       switch ( ord->id ) {
           case 1:
               if ( ord->nv != nvar )
                   error("nd_check : invalid order specification");
               break;
           default:
               break;
       }
       nd_init_ord(ord);
           nd_bpe = QTOS((Q)ARG7(BDY(tlist)));
       nd_setup_parameters(nvar,0);
   
           len = length(BDY(f));
           db = (NDV *)MALLOC(len*sizeof(NDV *));
           for ( i = 0, t = BDY(f); t; i++, t = NEXT(t) ) {
               ptozp((P)BDY(t),1,&dmy,&zp);
               b = ptondv(CO,vv,zp);
           ndv_mod(m,b);
                   ndv_mul_c(m,b,invm(HCM(b),m));
                   db[i] = b;
       }
   
           permtrace = BDY((LIST)ARG2(BDY(tlist)));
           intred = BDY((LIST)ARG3(BDY(tlist)));
           ind = BDY((LIST)ARG4(BDY(tlist)));
           perm = BDY((LIST)ARG0(permtrace));
           trace = NEXT(permtrace);
   
           for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {
                   j = QTOS((Q)ARG0(BDY((LIST)BDY(t))));
                   if ( j > i ) i = j;
           }
           n = i+1;
           pb = (NDV *)MALLOC(n*sizeof(NDV *));
           for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {
                   ti = BDY((LIST)BDY(t));
                   pb[QTOS((Q)ARG0(ti))] = db[QTOS((Q)ARG1(ti))];
           }
           for ( t = trace; t; t = NEXT(t) ) {
                   ti = BDY((LIST)BDY(t));
                   pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m);
                   if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; }
           if ( DP_Print ) {
                   fprintf(asir_out,"."); fflush(asir_out);
           }
           }
           for ( t = intred; t; t = NEXT(t) ) {
                   ti = BDY((LIST)BDY(t));
                   pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m);
                   if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; }
           if ( DP_Print ) {
                   fprintf(asir_out,"*"); fflush(asir_out);
           }
           }
       for ( r0 = 0, t = ind; t; t = NEXT(t) ) {
           NEXTNODE(r0,r);
                   b = pb[QTOS((Q)BDY(t))];
           ndv_mul_c(m,b,invm(HCM(b),m));
   #if 0
           BDY(r) = ndvtop(m,CO,vv,pb[QTOS((Q)BDY(t))]);
   #else
           BDY(r) = ndvtodp(m,pb[QTOS((Q)BDY(t))]);
   #endif
       }
       if ( r0 ) NEXT(r) = 0;
       MKLIST(*rp,r0);
       if ( DP_Print ) fprintf(asir_out,"\n");
   }
   
 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int f4,struct order_spec *ord,LIST *rp)  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int f4,struct order_spec *ord,LIST *rp)
 {  {
     VL tv,fv,vv,vc,av;      VL tv,fv,vv,vc,av;
Line 3025  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3475  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     LIST l1,l2,l3,l4,l5;      LIST l1,l2,l3,l4,l5;
     int *perm;      int *perm;
     int j,ret;      int j,ret;
     Q jq;      Q jq,bpe;
   
     nd_module = 0;      nd_module = 0;
     parse_nd_option(current_option);      parse_nd_option(current_option);
Line 3069  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3519  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     m = trace > 1 ? trace : get_lprime(mindex);      m = trace > 1 ? trace : get_lprime(mindex);
     nd_init_ord(ord);      nd_init_ord(ord);
     mrank = 0;      mrank = 0;
     for ( t = BDY(f), max = 0; t; t = NEXT(t) )      for ( t = BDY(f), max = 1; t; t = NEXT(t) )
         for ( tv = vv; tv; tv = NEXT(tv) ) {          for ( tv = vv; tv; tv = NEXT(tv) ) {
             if ( nd_module ) {              if ( nd_module ) {
                 s = BDY((LIST)BDY(t));                  s = BDY((LIST)BDY(t));
Line 3118  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3568  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;
         if ( Demand )          if ( Demand )
             nd_demand = 1;              nd_demand = 1;
         ndv_setup(m,1,fd0,0,0);          ret = ndv_setup(m,1,fd0,nd_gbblock?1:0,0);
         if ( nd_gentrace ) {          if ( nd_gentrace ) {
             MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);              MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);
         }          }
         cand = f4?nd_f4_trace(m,&perm):nd_gb_trace(m,ishomo || homo,&perm);          if ( ret )
         if ( !cand ) {              cand = f4?nd_f4_trace(m,&perm):nd_gb_trace(m,ishomo || homo,&perm);
           if ( !ret || !cand ) {
             /* failure */              /* failure */
             if ( trace > 1 ) { *rp = 0; return; }              if ( trace > 1 ) { *rp = 0; return; }
             else m = get_lprime(++mindex);              else m = get_lprime(++mindex);
Line 3144  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3597  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
         cand = ndv_reduceall(0,cand);          cand = ndv_reduceall(0,cand);
         cbpe = nd_bpe;          cbpe = nd_bpe;
         if ( nd_gentrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; }          if ( nd_gentrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; }
           get_eg(&eg0);
         if ( nocheck )          if ( nocheck )
             break;              break;
         get_eg(&eg0);  
         if ( ret = ndv_check_membership(0,in0,obpe,oadv,oepos,cand) ) {          if ( ret = ndv_check_membership(0,in0,obpe,oadv,oepos,cand) ) {
             if ( nd_gentrace ) {              if ( nd_gentrace ) {
                             tl3 = nd_alltracelist; nd_alltracelist = 0;                              tl3 = nd_alltracelist; nd_alltracelist = 0;
Line 3184  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3637  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     if ( nd_module ) BDY(r) = ndvtopl(0,CO,vv,BDY(r),mrank);      if ( nd_module ) BDY(r) = ndvtopl(0,CO,vv,BDY(r),mrank);
         else BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));          else BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r));
     }      }
     if ( nalg )      if ( nd_nalg )
         cand = postprocess_algcoef(av,alist,cand);          cand = postprocess_algcoef(av,alist,cand);
     MKLIST(*rp,cand);      MKLIST(*rp,cand);
     if ( nd_gentrace ) {      if ( nd_gentrace ) {
Line 3205  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3658  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
                 }                  }
         MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);          MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);
                 MKLIST(l5,tl4);                  MKLIST(l5,tl4);
         tr = mknode(7,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5); MKLIST(*rp,tr);                  STOQ(nd_bpe,bpe);
           tr = mknode(8,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5,bpe); MKLIST(*rp,tr);
     }      }
 }  }
   
Line 3429  void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos
Line 3883  void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos
     NMV m,mr0,mr,t;      NMV m,mr0,mr,t;
   
     len = p->len;      len = p->len;
     for ( m = BDY(p), i = 0, max = 0; i < len; NMV_OADV(m), i++ )      for ( m = BDY(p), i = 0, max = 1; i < len; NMV_OADV(m), i++ )
         max = MAX(max,TD(DL(m)));          max = MAX(max,TD(DL(m)));
     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);
Line 3622  void nd_free(ND p)
Line 4076  void nd_free(ND p)
   
 void ndv_free(NDV p)  void ndv_free(NDV p)
 {  {
     GC_free(BDY(p));      GCFREE(BDY(p));
 }  }
   
 void nd_append_red(UINT *d,int i)  void nd_append_red(UINT *d,int i)
Line 3733  void nd_setup_parameters(int nvar,int max) {
Line 4187  void nd_setup_parameters(int nvar,int max) {
         else if ( max < 65536 ) nd_bpe = 16;          else if ( max < 65536 ) nd_bpe = 16;
         else nd_bpe = 32;          else nd_bpe = 32;
     }      }
       if ( !do_weyl && weight_check && (current_dl_weight_vector || nd_matrix) ) {
           UINT t;
                   int st;
           int *v;
           /* t = max(weights) */
           t = 0;
           if ( current_dl_weight_vector )
               for ( i = 0, t = 0; i < nd_nvar; i++ ) {
                   if ( (st=current_dl_weight_vector[i]) < 0 ) st = -st;
                   if ( t < st ) t = st;
               }
           if ( nd_matrix )
               for ( i = 0; i < nd_matrix_len; i++ )
                   for ( j = 0, v = nd_matrix[i]; j < nd_nvar; j++ ) {
                       if ( (st=v[j]) < 0 ) st = -st;
                       if ( t < st ) t = st;
                                   }
           /* i = bitsize of t */
           for ( i = 0; t; t >>=1, i++ );
           /* i += bitsize of nd_nvar */
           for ( t = nd_nvar; t; t >>=1, i++);
           /* nd_bpe+i = bitsize of max(weights)*max(exp)*nd_nvar */
           if ( (nd_bpe+i) >= 31 )
               error("nd_setup_parameters : too large weight");
       }
     nd_epw = (sizeof(UINT)*8)/nd_bpe;      nd_epw = (sizeof(UINT)*8)/nd_bpe;
     elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0);      elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0);
     nd_exporigin = nd_get_exporigin(nd_ord);      nd_exporigin = nd_get_exporigin(nd_ord);
Line 3792  ND_pairs nd_reconstruct(int trace,ND_pairs d)
Line 4271  ND_pairs nd_reconstruct(int trace,ND_pairs d)
     prev_ndp_free_list = _ndp_free_list;      prev_ndp_free_list = _ndp_free_list;
     _nm_free_list = 0;      _nm_free_list = 0;
     _ndp_free_list = 0;      _ndp_free_list = 0;
     for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_ps[i],obpe,oadv,oepos);      for ( i = nd_psn-1; i >= 0; i-- ) {
           ndv_realloc(nd_ps[i],obpe,oadv,oepos);
           ndv_realloc(nd_ps_sym[i],obpe,oadv,oepos);
           ndv_realloc(nd_ps_gz[i],obpe,oadv,oepos);
       }
     if ( trace )      if ( trace )
         for ( i = nd_psn-1; i >= 0; i-- )          for ( i = nd_psn-1; i >= 0; i-- ) {
             ndv_realloc(nd_ps_trace[i],obpe,oadv,oepos);              ndv_realloc(nd_ps_trace[i],obpe,oadv,oepos);
               ndv_realloc(nd_ps_trace_sym[i],obpe,oadv,oepos);
           }
     s0 = 0;      s0 = 0;
     for ( t = d; t; t = NEXT(t) ) {      for ( t = d; t; t = NEXT(t) ) {
         NEXTND_pairs(s0,s);          NEXTND_pairs(s0,s);
Line 4033  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4518  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
     NEWNM(m); d = DL(m);      NEWNM(m); d = DL(m);
     if ( mod ) {      if ( mod ) {
         c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c;          c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c;
     } else      } else if ( nd_vc )
           mulp(nd_vc,CP(m0),CP(m1),&CP(m));
           else
         mulq(CQ(m0),CQ(m1),&CQ(m));          mulq(CQ(m0),CQ(m1),&CQ(m));
     for ( i = 0; i < nd_wpd; i++ ) d[i] = 0;      for ( i = 0; i < nd_wpd; i++ ) d[i] = 0;
     homo = n&1 ? 1 : 0;      homo = n&1 ? 1 : 0;
Line 4088  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4575  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
                         ndl_addto(DL(tab[u]),d);                          ndl_addto(DL(tab[u]),d);
                         if ( mod ) {                          if ( mod ) {
                             c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;                              c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1;
                         } else {                          } else if ( nd_vc )
                               mulp(nd_vc,CP(tab[u]),(P)q,&CP(tab[u]));
                                                   else {
                             mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;                              mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1;
                         }                          }
                     }                      }
Line 4100  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4589  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
                         ndl_add(DL(tab[u]),d,DL(t));                          ndl_add(DL(tab[u]),d,DL(t));
                         if ( mod ) {                          if ( mod ) {
                             c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;                              c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1;
                         } else                          } else if ( nd_vc )
                               mulp(nd_vc,CP(tab[u]),(P)q,&CP(t));
                                                   else
                             mulq(CQ(tab[u]),q,&CQ(t));                              mulq(CQ(tab[u]),q,&CQ(t));
                         *p = t;                          *p = t;
                     }                      }
Line 4310  NDV ndv_dup(int mod,NDV p)
Line 4801  NDV ndv_dup(int mod,NDV p)
     return d;      return d;
 }  }
   
   NDV ndvtondvgz(NDV p)
   {
           NDV r;
           int len,i;
           NMV t;
   
           r = ndv_dup(0,p);
           len = LEN(p);
       for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CZ(t) = ztogz(CQ(t));
           return r;
   }
   
   NDV ndvgztondv(NDV p)
   {
           NDV r;
           int len,i;
           NMV t;
   
           r = ndv_dup(0,p);
           len = LEN(p);
       for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CQ(t) = gztoz(CZ(t));
           return r;
   }
   
   NDV ndv_symbolic(int mod,NDV p)
   {
       NDV d;
       NMV t,m,m0;
       int i,len;
   
       if ( !p ) return 0;
       len = LEN(p);
       m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));
       for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) {
           ndl_copy(DL(t),DL(m));
           CQ(m) = ONE;
       }
       MKNDV(NV(p),m0,len,d);
       SG(d) = SG(p);
       return d;
   }
   
 ND nd_dup(ND p)  ND nd_dup(ND p)
 {  {
     ND d;      ND d;
Line 4327  ND nd_dup(ND p)
Line 4860  ND nd_dup(ND p)
     return d;      return d;
 }  }
   
   ND ndtondgz(ND p)
   {
           ND r;
           NM t;
   
           r = nd_dup(p);
       for ( t = BDY(r); t; t = NEXT(t) ) CZ(t) = ztogz(CQ(t));
           return r;
   }
   
   
   ND ndgztond(ND p)
   {
           ND r;
           NM t;
   
           r = nd_dup(p);
       for ( t = BDY(r); t; t = NEXT(t) ) CQ(t) = gztoz(CZ(t));
           return r;
   }
   
   
 /* XXX if p->len == 0 then it represents 0 */  /* XXX if p->len == 0 then it represents 0 */
   
 void ndv_mod(int mod,NDV p)  void ndv_mod(int mod,NDV p)
Line 4581  NDV ndtondv(int mod,ND p)
Line 5136  NDV ndtondv(int mod,ND p)
     if ( !p ) return 0;      if ( !p ) return 0;
     len = LEN(p);      len = LEN(p);
     if ( mod )      if ( mod )
         m0 = m = (NMV)GC_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);
 #if 0  #if 0
Line 4617  ND ndvtond(int mod,NDV p)
Line 5172  ND ndvtond(int mod,NDV p)
     return d;      return d;
 }  }
   
   DP ndvtodp(int mod,NDV p)
   {
       MP m,m0;
           DP d;
       NMV t;
       int i,len;
   
       if ( !p ) return 0;
       m0 = 0;
       len = p->len;
       for ( t = BDY(p), i = 0; i < len; NMV_ADV(t), i++ ) {
           NEXTMP(m0,m);
           m->dl = ndltodl(nd_nvar,DL(t));
           m->c = ndctop(mod,t->c);
       }
       NEXT(m) = 0;
           MKDP(nd_nvar,m0,d);
       SG(d) = SG(p);
       return d;
   }
   
   DP ndtodp(int mod,ND p)
   {
       MP m,m0;
           DP d;
       NM t;
       int i,len;
   
       if ( !p ) return 0;
       m0 = 0;
       len = p->len;
       for ( t = BDY(p); t; t = NEXT(t) ) {
           NEXTMP(m0,m);
           m->dl = ndltodl(nd_nvar,DL(t));
           m->c = ndctop(mod,t->c);
       }
       NEXT(m) = 0;
           MKDP(nd_nvar,m0,d);
       SG(d) = SG(p);
       return d;
   }
   
 void ndv_print(NDV p)  void ndv_print(NDV p)
 {  {
     NMV m;      NMV m;
Line 4684  NODE ndv_reducebase(NODE x,int *perm)
Line 5281  NODE ndv_reducebase(NODE x,int *perm)
   
 void nd_init_ord(struct order_spec *ord)  void nd_init_ord(struct order_spec *ord)
 {  {
     nd_module = (ord->id >= 256);    nd_module = (ord->id >= 256);
     if ( nd_module ) {
       nd_dcomp = -1;
       nd_ispot = ord->ispot;
       nd_pot_nelim = ord->pot_nelim;
       nd_poly_weight_len = ord->nv;
       nd_poly_weight = ord->top_weight;
       nd_module_rank = ord->module_rank;
       nd_module_weight = ord->module_top_weight;
     }
           nd_matrix = 0;
           nd_matrix_len = 0;
     switch ( ord->id ) {      switch ( ord->id ) {
         case 0:          case 0:
             switch ( ord->ord.simple ) {              switch ( ord->ord.simple ) {
Line 4738  void nd_init_ord(struct order_spec *ord)
Line 5346  void nd_init_ord(struct order_spec *ord)
   
         /* module order */          /* module order */
         case 256:          case 256:
             nd_ispot = ord->ispot;  
             nd_dcomp = -1;  
             switch ( ord->ord.simple ) {              switch ( ord->ord.simple ) {
                 case 0:                  case 0:
                     nd_isrlex = 1;                      nd_isrlex = 1;
Line 4759  void nd_init_ord(struct order_spec *ord)
Line 5365  void nd_init_ord(struct order_spec *ord)
             break;              break;
         case 257:          case 257:
             /* block order */              /* block order */
               nd_isrlex = 0;
             ndl_compare_function = ndl_module_block_compare;              ndl_compare_function = ndl_module_block_compare;
             break;              break;
         case 258:          case 258:
             /* matrix order */              /* matrix order */
               nd_isrlex = 0;
             nd_matrix_len = ord->ord.matrix.row;              nd_matrix_len = ord->ord.matrix.row;
             nd_matrix = ord->ord.matrix.matrix;              nd_matrix = ord->ord.matrix.matrix;
             ndl_compare_function = ndl_module_matrix_compare;              ndl_compare_function = ndl_module_matrix_compare;
             break;              break;
         case 259:          case 259:
             /* composite order */              /* composite order */
               nd_isrlex = 0;
             nd_worb_len = ord->ord.composite.length;              nd_worb_len = ord->ord.composite.length;
             nd_worb = ord->ord.composite.w_or_b;              nd_worb = ord->ord.composite.w_or_b;
             ndl_compare_function = ndl_module_composite_compare;              ndl_compare_function = ndl_module_composite_compare;
Line 4857  EPOS nd_create_epos(struct order_spec *ord)
Line 5466  EPOS nd_create_epos(struct order_spec *ord)
   
 /* external interface */  /* external interface */
   
 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec *ord,P *rp)  void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_spec *ord,Obj *rp)
 {  {
     NODE t,in0,in;      NODE t,in0,in;
     ND nd,nf;      ND ndf,nf;
     NDV ndv;      NDV ndvf;
     VL vv,tv;      VL vv,tv;
     int stat,nvar,max,e;      int stat,nvar,max,mrank;
     union oNDC dn;      union oNDC dn;
     Q cont;      Q cont;
     P pp;      P pp;
       LIST ppl;
   
     if ( !f ) {      if ( !f ) {
         *rp = 0;          *rp = 0;
Line 4875  void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec
Line 5485  void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec
     pltovl(v,&vv);      pltovl(v,&vv);
     for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );      for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
   
     /* get the degree bound */      /* max=65536 implies nd_bpe=32 */
     for ( t = BDY(g), max = 0; t; t = NEXT(t) )      max = 65536;
         for ( tv = vv; tv; tv = NEXT(tv) ) {  
             e = getdeg(tv->v,(P)BDY(t));  
             max = MAX(e,max);  
         }  
     for ( tv = vv; tv; tv = NEXT(tv) ) {  
         e = getdeg(tv->v,f);  
         max = MAX(e,max);  
     }  
   
           nd_module = 0;
           /* nd_module will be set if ord is a module ordering */
     nd_init_ord(ord);      nd_init_ord(ord);
     nd_setup_parameters(nvar,max);      nd_setup_parameters(nvar,max);
       if ( nd_module && OID(f) != O_LIST )
           error("nd_nf_p : the first argument must be a list");
           if ( nd_module ) mrank = length(BDY((LIST)f));
     /* conversion to ndv */      /* conversion to ndv */
     for ( in0 = 0, t = BDY(g); t; t = NEXT(t) ) {      for ( in0 = 0, t = BDY(g); t; t = NEXT(t) ) {
         NEXTNODE(in0,in);          NEXTNODE(in0,in);
         ptozp((P)BDY(t),1,&cont,&pp);          if ( nd_module ) {
         BDY(in) = (pointer)ptondv(CO,vv,pp);            if ( !BDY(t) || OID(BDY(t)) != O_LIST
                  || length(BDY((LIST)BDY(t))) != mrank )
                 error("nd_nf_p : inconsistent basis element");
             if ( !m ) pltozpl((LIST)BDY(t),&cont,&ppl);
             else ppl = (LIST)BDY(t);
             BDY(in) = (pointer)pltondv(CO,vv,ppl);
           } else {
             if ( !m ) ptozp((P)BDY(t),1,&cont,&pp);
             else pp = (P)BDY(t);
             BDY(in) = (pointer)ptondv(CO,vv,pp);
           }
         if ( m ) ndv_mod(m,(NDV)BDY(in));          if ( m ) ndv_mod(m,(NDV)BDY(in));
     }      }
     NEXTNODE(in0,in);      if ( in0 ) NEXT(in) = 0;
     BDY(in) = (pointer)ptondv(CO,vv,f);  
     if ( m ) ndv_mod(m,(NDV)BDY(in));  
     NEXT(in) = 0;  
   
       if ( nd_module ) ndvf = pltondv(CO,vv,(LIST)f);
       else ndvf = ptondv(CO,vv,(P)f);
       if ( m ) ndv_mod(m,ndvf);
       ndf = (pointer)ndvtond(m,ndvf);
   
     /* dont sort, dont removecont */      /* dont sort, dont removecont */
     ndv_setup(m,0,in0,1,1);      ndv_setup(m,0,in0,1,1);
     nd_psn--;  
     nd_scale=2;      nd_scale=2;
     while ( 1 ) {      stat = nd_nf(m,0,ndf,nd_ps,1,0,&nf);
         nd = (pointer)ndvtond(m,nd_ps[nd_psn]);      if ( !stat )
         stat = nd_nf(m,0,nd,nd_ps,1,0,&nf);          error("nd_nf_p : exponent too large");
         if ( !stat ) {      if ( nd_module ) *rp = (Obj)ndvtopl(m,CO,vv,ndtondv(m,nf),mrank);
             nd_psn++;      else *rp = (Obj)ndvtop(m,CO,vv,ndtondv(m,nf));
             nd_reconstruct(0,0);  
             nd_psn--;  
         } else  
             break;  
     }  
     *rp = ndvtop(m,CO,vv,ndtondv(m,nf));  
 }  }
   
 int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)  int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r)
Line 4950  int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)
Line 5561  int nd_to_vect_q(UINT *s0,int n,ND d,Q *r)
     return i;      return i;
 }  }
   
   unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash,ND p)
   {
       NM m;
       unsigned long *v;
       int i,j,h,size;
           UINT *s,*t;
   
           size = sizeof(unsigned long)*(n+BLEN-1)/BLEN;
       v = (unsigned long *)MALLOC_ATOMIC_IGNORE_OFF_PAGE(size);
       bzero(v,size);
       for ( i = j = 0, s = s0, m = BDY(p); m; j++, m = NEXT(m) ) {
                   t = DL(m);
                   h = ndl_hash_value(t);
           for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ );
               v[i/BLEN] |= 1L <<(i%BLEN);
       }
       return v;
   }
   
   int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,NM m,unsigned long *v)
   {
       NMV mr;
       UINT *d,*t,*s;
       int i,j,len,h,head;
   
       d = DL(m);
       len = LEN(p);
       t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));
       for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {
           ndl_add(d,DL(mr),t);
                   h = ndl_hash_value(t);
           for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ );
                   if ( j == 0 ) head = i;
               v[i/BLEN] |= 1L <<(i%BLEN);
       }
       return head;
   }
   
 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair)  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair)
 {  {
     NM m;      NM m;
Line 4973  Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p
Line 5622  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,NM_ind_pair pair)  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,int *s0hash,NM_ind_pair pair)
 {  {
     NM m;      NM m;
     NMV mr;      NMV mr;
Line 4982  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
Line 5631  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
     unsigned char *ivc;      unsigned char *ivc;
     unsigned short *ivs;      unsigned short *ivs;
     UINT *v,*ivi,*s0v;      UINT *v,*ivi,*s0v;
     int i,j,len,prev,diff,cdiff;      int i,j,len,prev,diff,cdiff,h;
     IndArray r;      IndArray r;
   struct oEGT eg0,eg1;
   
     m = pair->mul;      m = pair->mul;
     d = DL(m);      d = DL(m);
     p = nd_ps[pair->index];      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 *)ALLOCA(nd_wpd*sizeof(UINT));
     v = (unsigned int *)ALLOCA(len*sizeof(unsigned int));      v = (unsigned int *)ALLOCA(len*sizeof(unsigned int));
   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);
         for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );                  h = ndl_hash_value(t);
           for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ );
         v[j] = i;          v[j] = i;
     }      }
   get_eg(&eg1); add_eg(&eg_search,&eg0,&eg1);
     r = (IndArray)MALLOC(sizeof(struct oIndArray));      r = (IndArray)MALLOC(sizeof(struct oIndArray));
     r->head = v[0];      r->head = v[0];
     diff = 0;      diff = 0;
Line 5063  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
Line 5716  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
         k = ivect->head;          k = ivect->head;
         if ( svect[k] ) {          if ( svect[k] ) {
             maxrs = MAX(maxrs,rp0[i]->sugar);              maxrs = MAX(maxrs,rp0[i]->sugar);
             redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index];              redv = nd_demand?ndv_load(rp0[i]->index)
                        :(trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index]);
             len = LEN(redv); mr = BDY(redv);              len = LEN(redv); mr = BDY(redv);
             igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr);              igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr);
             chsgnq(cs,&mcs);              chsgnq(cs,&mcs);
Line 5115  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
Line 5769  int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr
     return maxrs;      return maxrs;
 }  }
   
   int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)
   {
       int i,j,k,l,len,pos,prev,nz;
       GZ cs,mcs,c1,c2,cr,gcd,t;
       IndArray ivect;
       unsigned char *ivc;
       unsigned short *ivs;
       unsigned int *ivi;
       NDV redv;
       NMV mr;
       NODE rp;
       int maxrs;
       double hmag;
           struct oVECT v;
   
       maxrs = 0;
       for ( i = 0; i < col && !gvect[i]; i++ );
       if ( i == col ) return maxrs;
       hmag = (double)n_bits_gz(gvect[i])*nd_scale;
       for ( i = 0; i < nred; i++ ) {
           ivect = imat[i];
           k = ivect->head;
           if ( gvect[k] ) {
               maxrs = MAX(maxrs,rp0[i]->sugar);
               redv = nd_ps_gz[rp0[i]->index];
               len = LEN(redv); mr = BDY(redv);
                           gcdgz(gvect[k],CZ(mr),&gcd);
                           divsgz(gvect[k],gcd,&cs);
                           divsgz(CZ(mr),gcd,&cr);
               chsgngz(cs,&mcs);
                           if ( !UNIGZ(cr) ) {
                  for ( j = 0; j < col; j++ ) {
                       mulgz(gvect[j],cr,&c1); gvect[j] = c1;
                   }
               }
               gvect[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]; prev = pos;
                           mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;
                       }
                       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;
                           mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;
                       }
                       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;
                           mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;
                       }
                       break;
               }
               for ( j = k+1; j < col && !gvect[j]; j++ );
               if ( j == col ) break;
               if ( hmag && ((double)n_bits_gz(gvect[j]) > hmag) ) {
                                   v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);
   #if 1
                                   for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }
   #endif
                           hmag = (double)n_bits_gz(gvect[j])*nd_scale;
               }
           }
       }
       for ( j = 0; j < col && !gvect[j]; j++ );
           if ( j < col ) {
                   v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);
                   for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }
           }
       if ( DP_Print ) {
           fprintf(asir_out,"-"); fflush(asir_out);
       }
       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 5141  int ndv_reduce_vect(int m,UINT *svect,int col,IndArray
Line 5877  int ndv_reduce_vect(int m,UINT *svect,int col,IndArray
                 case 1:                  case 1:
                     ivc = ivect->index.c;                      ivc = ivect->index.c;
                     for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {                      for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                         pos = prev+ivc[j]; c1 = CM(mr); c2 = svect[pos];                          pos = prev+ivc[j]; c1 = CM(mr); prev = pos;
                         prev = pos;                                                  if ( c1 ) {
                         DMA(c1,c,c2,up,lo);                                                          c2 = svect[pos];
                         if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;                                  DMA(c1,c,c2,up,lo);
                         } else svect[pos] = lo;                                  if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;
                                   } else svect[pos] = lo;
                                                   }
                     }                      }
                     break;                      break;
                 case 2:                  case 2:
                     ivs = ivect->index.s;                      ivs = ivect->index.s;
                     for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {                      for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                         pos = prev+ivs[j]; c1 = CM(mr); c2 = svect[pos];                          pos = prev+ivs[j]; c1 = CM(mr);
                         prev = pos;                          prev = pos;
                         DMA(c1,c,c2,up,lo);                                                  if ( c1 ) {
                         if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;                                                          c2 = svect[pos];
                         } else svect[pos] = lo;                                  DMA(c1,c,c2,up,lo);
                                   if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;
                                   } else svect[pos] = lo;
                                                   }
                     }                      }
                     break;                      break;
                 case 4:                  case 4:
                     ivi = ivect->index.i;                      ivi = ivect->index.i;
                     for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {                      for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {
                         pos = prev+ivi[j]; c1 = CM(mr); c2 = svect[pos];                          pos = prev+ivi[j]; c1 = CM(mr);
                         prev = pos;                          prev = pos;
                         DMA(c1,c,c2,up,lo);                                                  if ( c1 ) {
                         if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;                                                          c2 = svect[pos];
                         } else svect[pos] = lo;                                  DMA(c1,c,c2,up,lo);
                                   if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;
                                   } else svect[pos] = lo;
                                                   }
                     }                      }
                     break;                      break;
             }              }
Line 5237  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
Line 5981  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
     for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;      for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;
     if ( !len ) return 0;      if ( !len ) return 0;
     else {      else {
         mr0 = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len);          mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len);
 #if 0  #if 0
         ndv_alloc += nmv_adv*len;          ndv_alloc += nmv_adv*len;
 #endif  #endif
Line 5254  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
Line 5998  NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea
     }      }
 }  }
   
   NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect)
   {
       int j,k,len;
       UINT *p;
       NDV r;
       NMV mr0,mr;
   
       for ( j = 0, len = 0; j < col; j++ ) if ( vect[j/BLEN] & (1L<<(j%BLEN)) ) len++;
       if ( !len ) return 0;
       else {
           mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len);
           mr = mr0;
           p = s0vect;
           for ( j = 0; j < col; j++, p += nd_wpd )
                     if ( vect[j/BLEN] & (1L<<(j%BLEN)) ) {
               ndl_copy(p,DL(mr)); CM(mr) = 1; NMV_ADV(mr);
             }
           MKNDV(nd_nvar,mr0,len,r);
           return r;
       }
   }
   
 /* for preprocessed vector */  /* for preprocessed vector */
   
 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead,UINT *s0vect)  NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead,UINT *s0vect)
Line 5267  NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead
Line 6033  NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead
     for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;      for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;
     if ( !len ) return 0;      if ( !len ) return 0;
     else {      else {
         mr0 = (NMV)GC_malloc(nmv_adv*len);          mr0 = (NMV)MALLOC(nmv_adv*len);
 #if 0  #if 0
         ndv_alloc += nmv_adv*len;          ndv_alloc += nmv_adv*len;
 #endif  #endif
Line 5286  NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead
Line 6052  NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead
     }      }
 }  }
   
   NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhead,UINT *s0vect)
   {
       int j,k,len;
       UINT *p;
       Q 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(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 = vect[k++] ) {
                       ndl_copy(p,DL(mr)); CZ(mr) = c; 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 5299  NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)
Line 6093  NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)
     for ( j = 0, len = 0; j < col; j++ ) if ( vect[j] ) len++;      for ( j = 0, len = 0; j < col; j++ ) if ( vect[j] ) len++;
     if ( !len ) return 0;      if ( !len ) return 0;
     else {      else {
         mr0 = (NMV)GC_malloc(nmv_adv*len);          mr0 = (NMV)MALLOC(nmv_adv*len);
 #if 0  #if 0
         ndv_alloc += nmv_adv*len;          ndv_alloc += nmv_adv*len;
 #endif  #endif
Line 5345  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 6139  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
     NDV *ps;      NDV *ps;
   
     s0 = 0; rp0 = 0; col = 0;      s0 = 0; rp0 = 0; col = 0;
     ps = trace?nd_ps_trace:nd_ps;          if ( nd_demand )
           ps = trace?nd_ps_trace_sym:nd_ps_sym;
           else
           ps = trace?nd_ps_trace:nd_ps;
     while ( 1 ) {      while ( 1 ) {
         head = remove_head_pbucket_symbolic(bucket);          head = remove_head_pbucket_symbolic(bucket);
         if ( !head ) break;          if ( !head ) break;
Line 5379  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 6176  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
 NODE nd_f4(int m,int **indp)  NODE nd_f4(int m,int **indp)
 {  {
     int i,nh,stat,index;      int i,nh,stat,index;
     NODE r,g;      NODE r,g,tn0,tn,node;
     ND_pairs d,l,t;      ND_pairs d,l,t,ll0,ll;
           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;      NODE rp0,srp0,nflist,nzlist;
     int nsp,nred,col,rank,len,k,j,a;      int nsp,nred,col,rank,len,k,j,a,i1s,i2s;
     UINT c;      UINT c;
     UINT **spmat;      UINT **spmat;
     UINT *s0vect,*svect,*p,*v;      UINT *s0vect,*svect,*p,*v;
Line 5396  NODE nd_f4(int m,int **indp)
Line 6194  NODE nd_f4(int m,int **indp)
     int sugar;      int sugar;
     PGeoBucket bucket;      PGeoBucket bucket;
     struct oEGT eg0,eg1,eg_f4;      struct oEGT eg0,eg1,eg_f4;
       Q i1,i2,sugarq;
 #if 0  #if 0
     ndv_alloc = 0;      ndv_alloc = 0;
 #endif  #endif
Line 5405  NODE nd_f4(int m,int **indp)
Line 6203  NODE nd_f4(int m,int **indp)
         d = update_pairs(d,g,i,0);          d = update_pairs(d,g,i,0);
         g = update_base(g,i);          g = update_base(g,i);
     }      }
           nzlist = 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 = SG(l);
           if ( MaxDeg > 0 && sugar > MaxDeg ) break;
           if ( nd_nzlist ) {
               for ( tn = nd_nzlist; tn; tn = NEXT(tn) ) {
                   node = BDY((LIST)BDY(tn));
                               if ( QTOS((Q)ARG0(node)) == sugar ) break;
               }
                           if ( tn ) {
                                   for ( t = l, ll0 = 0; t; t = NEXT(t) ) {
                           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);
         if ( !stat ) {          if ( !stat ) {
Line 5429  NODE nd_f4(int m,int **indp)
Line 6251  NODE nd_f4(int m,int **indp)
         if ( DP_Print )          if ( DP_Print )
             fprintf(asir_out,"sugar=%d,symb=%fsec,",              fprintf(asir_out,"sugar=%d,symb=%fsec,",
                 sugar,eg_f4.exectime+eg_f4.gctime);                  sugar,eg_f4.exectime+eg_f4.gctime);
         if ( 1 )          nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0);
             nflist = nd_f4_red(m,l,0,s0vect,col,rp0,0);  
         else  
             nflist = nd_f4_red_dist(m,l,s0vect,col,rp0,0);  
         /* adding new bases */          /* adding new bases */
         for ( r = nflist; r; r = NEXT(r) ) {          for ( r = nflist; r; r = NEXT(r) ) {
             nf = (NDV)BDY(r);              nf = (NDV)BDY(r);
Line 5445  NODE nd_f4(int m,int **indp)
Line 6264  NODE nd_f4(int m,int **indp)
                 nd_removecont(m,nf1);                  nd_removecont(m,nf1);
                 nf = ndtondv(m,nf1);                  nf = ndtondv(m,nf1);
             }              }
             nh = ndv_newps(m,nf,0);              nh = ndv_newps(m,nf,0,1);
             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 ( nd_gentrace ) {
                           for ( t = ll, tn0 = 0; t; t = NEXT(t) ) {
                                   NEXTNODE(tn0,tn);
                   STOQ(t->i1,i1); STOQ(t->i2,i2);
                   node = mknode(2,i1,i2); MKLIST(l0,node);
                                   BDY(tn) = l0;
                           }
                           if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0);
               STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node);
               MKNODE(node,l1,nzlist); nzlist = node;
           }
     }      }
       if ( nd_gentrace ) {
                   MKLIST(l0,reverse_node(nzlist));
           MKNODE(nd_alltracelist,l0,0);
       }
 #if 0  #if 0
     fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);      fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);
 #endif  #endif
         conv_ilist(0,0,g,indp);          conv_ilist(nd_demand,0,g,indp);
     return g;      return g;
 }  }
   
Line 5487  NODE nd_f4_trace(int m,int **indp)
Line 6321  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 5545  NODE nd_f4_trace(int m,int **indp)
Line 6380  NODE nd_f4_trace(int m,int **indp)
             nfv = ndv_dup(0,nfqv);              nfv = ndv_dup(0,nfqv);
             ndv_mod(m,nfv);              ndv_mod(m,nfv);
             ndv_removecont(m,nfv);              ndv_removecont(m,nfv);
             nh = ndv_newps(0,nfv,nfqv);              nh = ndv_newps(0,nfv,nfqv,1);
             d = update_pairs(d,g,nh,0);              d = update_pairs(d,g,nh,0);
             g = update_base(g,nh);              g = update_base(g,nh);
         }          }
Line 5553  NODE nd_f4_trace(int m,int **indp)
Line 6388  NODE nd_f4_trace(int m,int **indp)
 #if 0  #if 0
     fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);      fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);
 #endif  #endif
           conv_ilist(nd_demand,1,g,indp);
       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);          conv_ilist(0,1,g,indp);
     return g;      return g;
 }  }
   
   int rref(matrix mat,int *sugar)
   {
     int row,col,i,j,k,l,s,wcol,wj;
     unsigned long bj;
     unsigned long **a;
     unsigned long *ai,*ak,*as,*t;
     int *pivot;
   
     row = mat->row;
     col = mat->col;
     a = mat->a;
     wcol = (col+BLEN-1)/BLEN;
     pivot = (int *)MALLOC_ATOMIC(row*sizeof(int));
     i = 0;
     for ( j = 0; j < col; j++ ) {
           wj = j/BLEN; bj = 1L<<(j%BLEN);
       for ( k = i; k < row; k++ )
             if ( a[k][wj] & bj ) break;
       if ( k == row ) continue;
           pivot[i] = j;
       if ( k != i ) {
            t = a[i]; a[i] = a[k]; a[k] = t;
            s = sugar[i]; sugar[i] = sugar[k]; sugar[k] = s;
           }
           ai = a[i];
       for ( k = i+1; k < row; k++ ) {
             ak = a[k];
             if ( ak[wj] & bj ) {
               for ( l = wj; l < wcol; l++ )
                     ak[l] ^= ai[l];
               sugar[k] = MAX(sugar[k],sugar[i]);
             }
           }
           i++;
     }
     for ( k = i-1; k >= 0; k-- ) {
       j = pivot[k]; wj = j/BLEN; bj = 1L<<(j%BLEN);
           ak = a[k];
       for ( s = 0; s < k; s++ ) {
             as = a[s];
         if ( as[wj] & bj ) {
           for ( l = wj; l < wcol; l++ )
                     as[l] ^= ak[l];
               sugar[s] = MAX(sugar[s],sugar[k]);
             }
           }
     }
     return i;
   }
   
   void print_matrix(matrix mat)
   {
     int row,col,i,j;
     unsigned long *ai;
   
     row = mat->row;
     col = mat->col;
     printf("%d x %d\n",row,col);
     for ( i = 0; i < row; i++ ) {
           ai = mat->a[i];
       for ( j = 0; j < col; j++ ) {
             if ( ai[j/BLEN] & (1L<<(j%BLEN)) ) putchar('1');
             else putchar('0');
           }
           putchar('\n');
     }
   }
   
   NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect);
   
   void red_by_vect_2(matrix mat,int *sugar,unsigned long *v,int rhead,int rsugar)
   {
     int row,col,wcol,wj,i,j;
     unsigned long bj;
     unsigned long *ai;
     unsigned long **a;
     int len;
     int *pos;
   
     row = mat->row;
     col = mat->col;
     wcol = (col+BLEN-1)/BLEN;
     pos = (int *)ALLOCA(wcol*sizeof(int));
     bzero(pos,wcol*sizeof(int));
     for ( i = j = 0; i < wcol; i++ )
       if ( v[i] ) pos[j++] = i;;
     len = j;
     wj = rhead/BLEN;
     bj = 1L<<rhead%BLEN;
     a = mat->a;
     for ( i = 0; i < row; i++ ) {
           ai = a[i];
       if ( ai[wj]&bj ) {
             for ( j = 0; j < len; j++ )
               ai[pos[j]] ^= v[pos[j]];
             sugar[i] = MAX(sugar[i],rsugar);
           }
     }
   }
   
   NODE nd_f4_red_2(ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)
   {
       int nsp,nred,i,i0,k,rank,row;
       NODE r0,rp;
       ND_pairs sp;
           ND spol;
           NM_ind_pair rt;
       int *s0hash;
           UINT *s;
           int *pivot,*sugar,*head;
           matrix mat;
       NM m;
       NODE r;
           struct oEGT eg0,eg1,eg2,eg_elim1,eg_elim2;
           int rhead,rsugar,size;
       unsigned long *v;
   
       get_eg(&eg0);
   init_eg(&eg_search);
       for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );
       nred = length(rp0);
       mat = alloc_matrix(nsp,col);
       s0hash = (int *)ALLOCA(col*sizeof(int));
       for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )
           s0hash[i] = ndl_hash_value(s);
   
           sugar = (int *)ALLOCA(nsp*sizeof(int));
           for ( i = 0, sp = sp0; sp; sp = NEXT(sp) ) {
                   nd_sp(2,0,sp,&spol);
                   if ( spol ) {
                 mat->a[i] = nd_to_vect_2(s0vect,col,s0hash,spol);
                     sugar[i] = SG(spol);
                     i++;
                   }
           }
           mat->row = i;
       if ( DP_Print ) {
         fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out);
       }
           size = ((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++ ) {
                   rt = (NM_ind_pair)BDY(rp);
                   bzero(v,size);
           rhead = nd_nm_to_vect_2(s0vect,col,s0hash,nd_ps[rt->index],rt->mul,v);
                   rsugar = SG(nd_ps[rt->index])+TD(DL(rt->mul));
               red_by_vect_2(mat,sugar,v,rhead,rsugar);
           }
   
       get_eg(&eg1);
       init_eg(&eg_elim1); add_eg(&eg_elim1,&eg0,&eg1);
           rank = rref(mat,sugar);
   
       for ( i = 0, r0 = 0; i < rank; i++ ) {
         NEXTNODE(r0,r);
             BDY(r) = (pointer)vect_to_ndv_2(mat->a[i],col,s0vect);
         SG((NDV)BDY(r)) = sugar[i];
       }
       if ( r0 ) NEXT(r) = 0;
       get_eg(&eg2);
       init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2);
       if ( DP_Print ) {
           fprintf(asir_out,"elim1=%fsec,elim2=%fsec\n",
                     eg_elim1.exectime+eg_elim1.gctime,eg_elim2.exectime+eg_elim2.gctime);
           fflush(asir_out);
           }
       return r0;
   }
   
   
 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)
 {  {
     IndArray *imat;      IndArray *imat;
Line 5565  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
Line 6673  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
     NODE r0,rp;      NODE r0,rp;
     ND_pairs sp;      ND_pairs sp;
     NM_ind_pair *rvect;      NM_ind_pair *rvect;
       UINT *s;
       int *s0hash;
   
       if ( m == 2 && nd_rref2 )
              return nd_f4_red_2(sp0,s0vect,col,rp0,nz);
   
   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 *)ALLOCA(nred*sizeof(IndArray));
Line 5573  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
Line 6687  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
     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 */
       if ( DP_Print ) {
             fprintf(stderr,"%dx%d,",nsp+nred,col);
       }
     rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair));      rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair));
       s0hash = (int *)ALLOCA(col*sizeof(int));
       for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )
           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,rvect[i]);          imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,s0hash,rvect[i]);
         rhead[imat[i]->head] = 1;          rhead[imat[i]->head] = 1;
     }      }
     if ( m )      if ( m )
         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);
     else      else
         r0 = nd_f4_red_q_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);
       if ( DP_Print ) print_eg("search",&eg_search);
     return r0;      return r0;
 }  }
   
Line 5635  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 6756  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
         fflush(asir_out);          fflush(asir_out);
     }      }
     /* free index arrays */      /* free index arrays */
     for ( i = 0; i < nred; i++ ) GC_free(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 *)ALLOCA(spcol*sizeof(int));
Line 5648  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
Line 6769  NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s
         NEXTNODE(r0,r); BDY(r) =          NEXTNODE(r0,r); BDY(r) =
             (pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);              (pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect);
         SG((NDV)BDY(r)) = spsugar[i];          SG((NDV)BDY(r)) = spsugar[i];
         GC_free(spmat[i]);          GCFREE(spmat[i]);
     }      }
     if ( r0 ) NEXT(r) = 0;      if ( r0 ) NEXT(r) = 0;
   
     for ( ; i < sprow; i++ ) GC_free(spmat[i]);      for ( ; i < sprow; i++ ) GCFREE(spmat[i]);
     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 ) {
Line 5716  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 6837  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
         fflush(asir_out);          fflush(asir_out);
     }      }
     /* free index arrays */      /* free index arrays */
 /*    for ( i = 0; i < nred; i++ ) GC_free(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 *)ALLOCA(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 *)ALLOCA(rank*sizeof(pointer));
     for ( i = 0; i < rank; i++ ) {      for ( i = 0; i < rank; i++ ) {
   #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);
         SG((NDV)w[rank-i-1]) = spsugar[i];          SG((NDV)w[rank-i-1]) = spsugar[i];
 /*        GC_free(spmat[i]); */  #else
           w[i] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);
           SG((NDV)w[i]) = spsugar[i];
   #endif
   /*        GCFREE(spmat[i]); */
     }      }
 #if 0  #if 0
     qsort(w,rank,sizeof(NDV),      qsort(w,rank,sizeof(NDV),
Line 5737  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 6863  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
     }      }
     if ( r0 ) NEXT(r) = 0;      if ( r0 ) NEXT(r) = 0;
   
 /*    for ( ; i < sprow; i++ ) GC_free(spmat[i]); */  /*    for ( ; i < sprow; i++ ) GCFREE(spmat[i]); */
     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 ) {
Line 5748  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
Line 6874  NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U
     }      }
     return r0;      return r0;
 }  }
   
   NODE nd_f4_red_gz_main(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;
       GZ **spmat;
       GZ *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 = (GZ **)ALLOCA(nsp*sizeof(GZ *));
       svect = (GZ *)ALLOCA(col*sizeof(GZ));
       spsugar = (int *)ALLOCA(nsp*sizeof(Q));
       for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {
           nd_sp(0,trace,sp,&spol);
           if ( !spol ) continue;
                   spol = ndtondgz(spol);
           nd_to_vect_q(s0vect,col,spol,(Q *)svect);
           maxrs = ndv_reduce_vect_gz(svect,trace,col,imat,rvect,nred);
           for ( i = 0; i < col; i++ ) if ( svect[i] ) break;
           if ( i < col ) {
               spmat[sprow] = v = (GZ *)MALLOC(spcol*sizeof(GZ));
               for ( j = k = 0; j < col; j++ )
                   if ( !rhead[j] ) v[k++] = svect[j];
               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=%fsec,",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 *)ALLOCA(spcol*sizeof(int));
       rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat);
       w = (pointer *)ALLOCA(rank*sizeof(pointer));
       for ( i = 0; i < rank; i++ ) {
   #if 0
           w[rank-i-1] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);
                   w[rank-i-1] = ndvgztondv(w[rank-i-1]);
           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] = ndvgztondv(w[i]);
           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=%fsec\n",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,"%fsec\n",eg_f4.exectime+eg_f4.gctime);
       }
       return r0;
   }
   #else
 void printm(Q **mat,int row,int col)  void printm(Q **mat,int row,int col)
 {  {
     int i,j;      int i,j;
Line 5869  NDV nd_recv_ndv()
Line 7080  NDV nd_recv_ndv()
     len = nd_recv_int();      len = nd_recv_int();
     if ( !len ) return 0;      if ( !len ) return 0;
     else {      else {
         m0 = m = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len);          m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len);
 #if 0  #if 0
         ndv_alloc += len*nmv_adv;          ndv_alloc += len*nmv_adv;
 #endif  #endif
Line 5900  int ox_exec_f4_red(Q proc)
Line 7111  int ox_exec_f4_red(Q proc)
     return s;      return s;
 }  }
   
   #if 0
 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)  NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)
 {  {
     int nsp,nred;      int nsp,nred;
Line 6062  void nd_exec_f4_red_dist()
Line 7274  void nd_exec_f4_red_dist()
     }      }
     fflush(nd_write);      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 mod,i,j,t,c,rank,rank0,inv;      int i,j,t,c,rank,inv;
     int *ci,*ri;      int *ci,*ri;
     Q dn;      Q dn;
     MAT m,nm;      MAT m,nm;
     int **wmat;  
   
     /* XXX */  
     mod = 99999989;  
     wmat = (int **)ALLOCA(row*sizeof(int *));  
     for ( i = 0; i < row; i++ ) {  
         wmat[i] = (int *)ALLOCA(col*sizeof(int));  
         for ( j = 0; j < col; j++ ) {  
             if ( mat0[i][j] ) {  
                 t = rem(NM(mat0[i][j]),mod);  
                 if ( SGN(mat0[i][j]) < 0 ) t = mod-t;  
                 wmat[i][j] = t;  
             } else  
                 wmat[i][j] = 0;  
         }  
     }  
     rank0 = nd_gauss_elim_mod(wmat,sugar,0,row,col,mod,colstat);  
     NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;      NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;
     rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);      rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);
     if ( rank != rank0 )  
         error("afo");  
     for ( i = 0; i < row; i++ )      for ( i = 0; i < row; i++ )
         for ( j = 0; j < col; j++ )          for ( j = 0; j < col; j++ )
             mat0[i][j] = 0;              mat0[i][j] = 0;
Line 6099  int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co
Line 7294  int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co
         for ( j = 0; j < c; j++ )          for ( j = 0; j < c; j++ )
             mat0[i][ci[j]] = (Q)BDY(nm)[i][j];              mat0[i][ci[j]] = (Q)BDY(nm)[i][j];
     }      }
     inv = invm(rem(NM(dn),mod),mod);      return rank;
     if ( SGN(dn) < 0 ) inv = mod-inv;  }
   
   int nd_gauss_elim_gz(GZ **mat0,int *sugar,int row,int col,int *colstat)
   {
       int i,j,t,c,rank,inv;
       int *ci,*ri;
       GZ dn;
       MAT m,nm;
   
       NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;
       rank = gz_generic_gauss_elim(m,&nm,&dn,&ri,&ci);
     for ( i = 0; i < row; i++ )      for ( i = 0; i < row; i++ )
         for ( j = 0; j < col; j++ ) {          for ( j = 0; j < col; j++ )
             if ( mat0[i][j] ) {              mat0[i][j] = 0;
                 t = rem(NM(mat0[i][j]),mod);      c = col-rank;
                 if ( SGN(mat0[i][j]) < 0 ) t = mod-t;      for ( i = 0; i < rank; i++ ) {
             } else          mat0[i][ri[i]] = dn;
                 t = 0;          for ( j = 0; j < c; j++ )
             c = dmar(t,inv,0,mod);              mat0[i][ci[j]] = (GZ)BDY(nm)[i][j];
             if ( wmat[i][j] != c )      }
                 error("afo");  
         }  
     return rank;      return rank;
 }  }
   
Line 6291  void ndv_save(NDV p,int index)
Line 7494  void ndv_save(NDV p,int index)
     fclose(s);      fclose(s);
 }  }
   
   void nd_save_mod(ND p,int index)
   {
       FILE *s;
       char name[BUFSIZ];
       int nv,sugar,len,c;
       NM m;
   
       sprintf(name,"%s/%d",Demand,index);
       s = fopen(name,"w");
       if ( !p ) {
                   len = 0;
           write_int(s,&len);
                   fclose(s);
           return;
       }
       nv = NV(p);
       sugar = SG(p);
       len = LEN(p);
       write_int(s,&nv); write_int(s,&sugar); write_int(s,&len);
           for ( m = BDY(p); m; m = NEXT(m) ) {
             c = CM(m); write_int(s,&c);
             write_intarray(s,DL(m),nd_wpd);
           }
       fclose(s);
   }
   
 NDV ndv_load(int index)  NDV ndv_load(int index)
 {  {
     FILE *s;      FILE *s;
Line 6335  NDV ndv_load(int index)
Line 7564  NDV ndv_load(int index)
     return d;      return d;
 }  }
   
   ND nd_load_mod(int index)
   {
       FILE *s;
       char name[BUFSIZ];
       int nv,sugar,len,i,c;
           ND d;
       NM m0,m;
   
       sprintf(name,"%s/%d",Demand,index);
       s = fopen(name,"r");
           /* if the file does not exist, it means p[index]=0 */
       if ( !s ) return 0;
   
       read_int(s,&nv);
           if ( !nv ) { fclose(s); return 0; }
   
       read_int(s,&sugar);
       read_int(s,&len);
           for ( m0 = 0, i = 0; i < len; i++ ) {
                   NEXTNM(m0,m);
                   read_int(s,&c); CM(m) = c;
                   read_intarray(s,DL(m),nd_wpd);
           }
           NEXT(m) = 0;
       MKND(nv,m0,len,d);
       SG(d) = sugar;
           fclose(s);
       return d;
   }
   
 void nd_det(int mod,MAT f,P *rp)  void nd_det(int mod,MAT f,P *rp)
 {  {
     VL fv,tv;      VL fv,tv;
Line 6399  void nd_det(int mod,MAT f,P *rp)
Line 7658  void nd_det(int mod,MAT f,P *rp)
         m = (pointer **)w;          m = (pointer **)w;
     }      }
   
     for ( i = 0, max = 0; i < n; i++ )      for ( i = 0, max = 1; i < n; i++ )
         for ( j = 0; j < n; j++ )          for ( j = 0; j < n; j++ )
             for ( tv = fv; tv; tv = NEXT(tv) ) {              for ( tv = fv; tv; tv = NEXT(tv) ) {
                 e = getdeg(tv->v,(P)m[i][j]);                  e = getdeg(tv->v,(P)m[i][j]);
Line 6407  void nd_det(int mod,MAT f,P *rp)
Line 7666  void nd_det(int mod,MAT f,P *rp)
             }              }
     nd_setup_parameters(nvar,max);      nd_setup_parameters(nvar,max);
     dm = (NDV **)almat_pointer(n,n);      dm = (NDV **)almat_pointer(n,n);
     for ( i = 0, max = 0; i < n; i++ )      for ( i = 0, max = 1; i < n; i++ )
         for ( j = 0; j < n; j++ ) {          for ( j = 0; j < n; j++ ) {
             dm[i][j] = ptondv(CO,fv,m[i][j]);              dm[i][j] = ptondv(CO,fv,m[i][j]);
             if ( mod ) ndv_mod(mod,dm[i][j]);              if ( mod ) ndv_mod(mod,dm[i][j]);
Line 6417  void nd_det(int mod,MAT f,P *rp)
Line 7676  void nd_det(int mod,MAT f,P *rp)
     if ( mod ) ndv_mod(mod,d);      if ( mod ) ndv_mod(mod,d);
     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 ) fprintf(stderr,".",j);          if ( DP_Print ) {
             fprintf(stderr,".",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 ) {
             *rp = 0;              *rp = 0;
Line 6476  void nd_det(int mod,MAT f,P *rp)
Line 7737  void nd_det(int mod,MAT f,P *rp)
         }          }
         d = mjj;          d = mjj;
     }      }
     if ( DP_Print ) fprintf(stderr,"\n",k);      if ( DP_Print ) {
         fprintf(stderr,"\n",k);
       }
     if ( sgn < 0 )      if ( sgn < 0 )
         if ( mod )          if ( mod )
             ndv_mul_c(mod,d,mod-1);              ndv_mul_c(mod,d,mod-1);
Line 6767  void finalize_tracelist(int i,P cont)
Line 8030  void finalize_tracelist(int i,P cont)
      Q iq;       Q iq;
   
          if ( !UNIQ(cont) ) {           if ( !UNIQ(cont) ) {
          node = mknode(4,0,0,0,cont);           node = mknode(4,NULLP,NULLP,NULLP,cont);
          MKLIST(l,node); MKNODE(node,l,nd_tracelist);           MKLIST(l,node); MKNODE(node,l,nd_tracelist);
                  nd_tracelist = node;                   nd_tracelist = node;
          }           }
Line 6796  void conv_ilist(int demand,int trace,NODE g,int **indp
Line 8059  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;      NODE t,p,u;
           int i,s;
     char *key;      char *key;
     Obj value;      Obj value;
   
     nd_gentrace = 0; nd_gensyz = 0;      nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0;
           nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0;
           nd_splist = 0; nd_check_splist = 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 6809  void parse_nd_option(NODE opt)
Line 8075  void parse_nd_option(NODE opt)
             nd_gentrace = value?1:0;              nd_gentrace = value?1:0;
         else if ( !strcmp(key,"gensyz") )          else if ( !strcmp(key,"gensyz") )
             nd_gensyz = value?1:0;              nd_gensyz = value?1:0;
           else if ( !strcmp(key,"nora") )
               nd_nora = value?1:0;
           else if ( !strcmp(key,"gbblock") ) {
                           if ( !value || OID(value) != O_LIST )
                                   error("nd_* : invalid value for gbblock option");
                           u = BDY((LIST)value);
               nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int));
                           for ( i = 0; u; u = NEXT(u) ) {
                                   p = BDY((LIST)BDY(u));
                                   s = nd_gbblock[i++] = QTOS((Q)BDY(p));
                                   nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1;
                           }
                           nd_gbblock[i] = -1;
                   } else if ( !strcmp(key,"newelim") )
               nd_newelim = value?1:0;
                   else if ( !strcmp(key,"intersect") )
               nd_intersect = value?1:0;
                   else if ( !strcmp(key,"trace") ) {
              u = BDY((LIST)value);
                      nd_nzlist = BDY((LIST)ARG2(u));
                      nd_bpe = QTOS((Q)ARG3(u));
                   } else if ( !strcmp(key,"splist") )
               nd_splist = value?1:0;
                   else if ( !strcmp(key,"check_splist") ) {
                           nd_check_splist = BDY((LIST)value);
                   }
     }      }
   }
   
   ND mdptond(DP d);
   ND nd_mul_nm(int mod,NM m0,ND p);
   ND *btog(NODE ti,ND **p,int nb,int mod);
   ND btog_one(NODE ti,ND *p,int nb,int mod);
   MAT nd_btog(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,MAT *rp);
   VECT nd_btog_one(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,int pos,MAT *rp);
   
   /* d:monomial */
   ND mdptond(DP d)
   {
     NM m;
     ND r;
   
     if ( OID(d) == 1 )
           r = ptond(CO,CO,(P)d);
     else {
       NEWNM(m);
       dltondl(NV(d),BDY(d)->dl,DL(m));
       CQ(m) = (Q)BDY(d)->c;
       NEXT(m) = 0;
       MKND(NV(d),m,1,r);
     }
       return r;
   }
   
   ND nd_mul_nm(int mod,NM m0,ND p)
   {
     UINT *d0;
     int c0,c1,c;
     NM tm,mr,mr0;
     ND r;
   
     if ( !p ) return 0;
     d0 = DL(m0);
     c0 = CM(m0);
     mr0 = 0;
     for ( tm = BDY(p); tm; tm = NEXT(tm) ) {
       NEXTNM(mr0,mr);
           c = CM(tm); DMAR(c0,c,0,mod,c1); CM(mr) = c1;
           ndl_add(d0,DL(tm),DL(mr));
     }
     NEXT(mr) = 0;
     MKND(NV(p),mr0,LEN(p),r);
     return r;
   }
   
   ND *btog(NODE ti,ND **p,int nb,int mod)
   {
     PGeoBucket *r;
     int i,ci;
     NODE t,s;
     ND m,tp;
     ND *pi,*rd;
     P c;
   
     r = (PGeoBucket *)MALLOC(nb*sizeof(PGeoBucket));
     for ( i = 0; i < nb; i++ )
           r[i] = create_pbucket();
     for ( t = ti; t; t = NEXT(t) ) {
           s = BDY((LIST)BDY(t));
       if ( ARG0(s) ) {
             m = mdptond((DP)ARG2(s));
             ptomp(mod,(P)HCQ(m),&c);
             if ( ci = ((MQ)c)->cont ) {
               HCM(m) = ci;
               pi = p[QTOS((Q)ARG1(s))];
               for ( i = 0; i < nb; i++ ) {
                     tp = nd_mul_nm(mod,BDY(m),pi[i]);
                 add_pbucket(mod,r[i],tp);
               }
             }
             ci = 1;
       } else {
             ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont;
             ci = invm(ci,mod);
           }
     }
     rd = (ND *)MALLOC(nb*sizeof(ND));
     for ( i = 0; i < nb; i++ )
           rd[i] = normalize_pbucket(mod,r[i]);
     if ( ci != 1 )
       for ( i = 0; i < nb; i++ ) nd_mul_c(mod,rd[i],ci);
      return rd;
   }
   
   ND btog_one(NODE ti,ND *p,int nb,int mod)
   {
     PGeoBucket r;
     int i,ci,j;
     NODE t,s;
     ND m,tp;
     ND pi,rd;
     P c;
   
     r = create_pbucket();
     for ( t = ti; t; t = NEXT(t) ) {
           s = BDY((LIST)BDY(t));
       if ( ARG0(s) ) {
             m = mdptond((DP)ARG2(s));
             ptomp(mod,(P)HCQ(m),&c);
             if ( ci = ((MQ)c)->cont ) {
               HCM(m) = ci;
               pi = p[j=QTOS((Q)ARG1(s))];
                   if ( !pi ) {
                     pi = nd_load_mod(j);
                     tp = nd_mul_nm(mod,BDY(m),pi);
                     nd_free(pi);
                 add_pbucket(mod,r,tp);
                   } else {
                     tp = nd_mul_nm(mod,BDY(m),pi);
                 add_pbucket(mod,r,tp);
               }
             }
             ci = 1;
       } else {
             ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont;
             ci = invm(ci,mod);
           }
     }
     rd = normalize_pbucket(mod,r);
     free_pbucket(r);
     if ( ci != 1 ) nd_mul_c(mod,rd,ci);
     return rd;
   }
   
   MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *ord,LIST tlist,MAT *rp)
   {
     int i,j,n,m,nb,pi0,pi1,nvar;
     VL fv,tv,vv;
     NODE permtrace,perm,trace,intred,ind,t,pi,ti;
     ND **p;
     ND *c;
     ND u;
     P inv;
     MAT mat;
   
     parse_nd_option(current_option);
     get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);
     for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
     switch ( ord->id ) {
       case 1:
         if ( ord->nv != nvar )
           error("nd_check : invalid order specification");
         break;
       default:
         break;
     }
     nd_init_ord(ord);
   #if 0
     nd_bpe = QTOS((Q)ARG7(BDY(tlist)));
   #else
     nd_bpe = 32;
   #endif
     nd_setup_parameters(nvar,0);
     permtrace = BDY((LIST)ARG2(BDY(tlist)));
     intred = BDY((LIST)ARG3(BDY(tlist)));
     ind = BDY((LIST)ARG4(BDY(tlist)));
     perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);
     for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {
           j = QTOS((Q)BDY(BDY((LIST)BDY(t))));
           if ( j > i ) i = j;
     }
     n = i+1;
     nb = length(BDY(f));
     p = (ND **)MALLOC(n*sizeof(ND *));
     for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {
       pi = BDY((LIST)BDY(t));
           pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi));
           p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND));
           ptomp(mod,(P)ARG2(pi),&inv);
           ((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);
           u = ptond(CO,vv,(P)ONE);
           HCM(u) = ((MQ)inv)->cont;
           c[pi1] = u;
     }
     for ( t = trace,i=0; t; t = NEXT(t), i++ ) {
           printf("%d ",i); fflush(stdout);
       ti = BDY((LIST)BDY(t));
       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++ ) {
           printf("%d ",i); fflush(stdout);
       ti = BDY((LIST)BDY(t));
       p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod);
       if ( j == 441 )
                   printf("afo");
     }
     m = length(ind);
     MKMAT(mat,nb,m);
     for ( j = 0, t = ind; j < m; j++, t = NEXT(t) )
       for ( i = 0, c = p[QTOS((Q)BDY(t))]; i < nb; i++ )
                   BDY(mat)[i][j] = ndtodp(mod,c[i]);
     return mat;
   }
   
   VECT nd_btog_one(LIST f,LIST v,int mod,struct order_spec *ord,
     LIST tlist,int pos,MAT *rp)
   {
     int i,j,n,m,nb,pi0,pi1,nvar;
     VL fv,tv,vv;
     NODE permtrace,perm,trace,intred,ind,t,pi,ti;
     ND *p;
     ND *c;
     ND u;
     P inv;
     VECT vect;
   
     parse_nd_option(current_option);
     get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc);
     for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );
     switch ( ord->id ) {
       case 1:
         if ( ord->nv != nvar )
           error("nd_check : invalid order specification");
         break;
       default:
         break;
     }
     nd_init_ord(ord);
   #if 0
     nd_bpe = QTOS((Q)ARG7(BDY(tlist)));
   #else
     nd_bpe = 32;
   #endif
     nd_setup_parameters(nvar,0);
     permtrace = BDY((LIST)ARG2(BDY(tlist)));
     intred = BDY((LIST)ARG3(BDY(tlist)));
     ind = BDY((LIST)ARG4(BDY(tlist)));
     perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace);
     for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) {
           j = QTOS((Q)BDY(BDY((LIST)BDY(t))));
           if ( j > i ) i = j;
     }
     n = i+1;
     nb = length(BDY(f));
     p = (ND *)MALLOC(n*sizeof(ND *));
     for ( t = perm, i = 0; t; t = NEXT(t), i++ ) {
       pi = BDY((LIST)BDY(t));
           pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi));
           if ( pi1 == pos ) {
             ptomp(mod,(P)ARG2(pi),&inv);
             ((MQ)inv)->cont = invm(((MQ)inv)->cont,mod);
             u = ptond(CO,vv,(P)ONE);
             HCM(u) = ((MQ)inv)->cont;
             p[pi0] = u;
       }
     }
     for ( t = trace,i=0; t; t = NEXT(t), i++ ) {
           printf("%d ",i); fflush(stdout);
       ti = BDY((LIST)BDY(t));
       p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);
       if ( Demand ) {
           nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;
           }
     }
     for ( t = intred, i=0; t; t = NEXT(t), i++ ) {
           printf("%d ",i); fflush(stdout);
       ti = BDY((LIST)BDY(t));
       p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod);
       if ( Demand ) {
           nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0;
           }
     }
     m = length(ind);
     MKVECT(vect,m);
     for ( j = 0, t = ind; j < m; j++, t = NEXT(t) ) {
           u = p[QTOS((Q)BDY(t))];
           if ( !u ) {
             u = nd_load_mod(QTOS((Q)BDY(t)));
             BDY(vect)[j] = ndtodp(mod,u);
             nd_free(u);
           } else
             BDY(vect)[j] = ndtodp(mod,u);
     }
     return vect;
 }  }
Legend:
Removed from v.1.172  
changed lines
  Added in v.1.229
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>