[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.168 and 1.199

version 1.168, 2009/02/09 10:21:29 version 1.199, 2012/08/27 05:38:00
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.167 2009/02/08 02:47:09 noro Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.198 2012/04/10 07:15:07 noro Exp $ */
   
 #include "nd.h"  #include "nd.h"
   
   struct oEGT eg_search;
   
 int diag_period = 6;  int diag_period = 6;
 int (*ndl_compare_function)(UINT *a1,UINT *a2);  int (*ndl_compare_function)(UINT *a1,UINT *a2);
 int nd_dcomp;  int nd_dcomp;
Line 46  static int nd_worb_len;
Line 48  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 NODE nd_tracelist;  static NODE nd_tracelist;
 static NODE nd_alltracelist;  static NODE nd_alltracelist;
   static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect;
   static int *nd_gbblock;
   
 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 67  P ndc_div(int mod,union oNDC a,union oNDC b);
Line 71  P ndc_div(int mod,union oNDC a,union oNDC b);
 P ndctop(int mod,union oNDC c);  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 dltondl(int n,DL dl,UINT *r);
   DP ndvtodp(int mod,NDV p);
   
 extern int Denominator,DP_Multiple;  extern int Denominator,DP_Multiple;
   
Line 579  int ndl_module_grlex_compare(UINT *d1,UINT *d2)
Line 586  int ndl_module_grlex_compare(UINT *d1,UINT *d2)
     int i,c;      int i,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 1325  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
Line 1340  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
             p = nd_demand ? ndv_load(index) : ps[index];              p = nd_demand ? ndv_load(index) : ps[index];
             /* d+g -> div*(d+g)+mul*p */              /* d+g -> div*(d+g)+mul*p */
             g = nd_reduce2(mod,d,g,p,mul,dn,&div);              g = nd_reduce2(mod,d,g,p,mul,dn,&div);
             if ( GenTrace ) {              if ( nd_gentrace ) {
                 /* Trace=[div,index,mul,ONE] */                  /* Trace=[div,index,mul,ONE] */
                 STOQ(index,iq);                  STOQ(index,iq);
                 nmtodp(mod,mul,&dmul);                  nmtodp(mod,mul,&dmul);
                 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 || GenTrace ) {                  if ( dn || nd_gentrace ) {
                     /* overwrite cont : Trace=[div,index,mul,cont] */                      /* overwrite cont : Trace=[div,index,mul,cont] */
                     cont = ndc_div(mod,hg,HCU(g));                      cont = ndc_div(mod,hg,HCU(g));
                     if ( dn ) {                      if ( dn ) {
Line 1344  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
Line 1359  int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND
                             reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1;                              reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1;
                         } else divq(dn->z,(Q)cont,&dn->z);                          } else divq(dn->z,(Q)cont,&dn->z);
                     }                      }
                     if ( GenTrace && !UNIQ(cont) ) ARG3(node) = (pointer)cont;                      if ( nd_gentrace && !UNIQ(cont) ) ARG3(node) = (pointer)cont;
                 }                  }
                 hmag = ((double)p_mag(HCP(g)))*nd_scale;                  hmag = ((double)p_mag(HCP(g)))*nd_scale;
             }              }
Line 1476  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
Line 1491  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp
   
 /* input : list of NDV, cand : list of NDV */  /* input : list of NDV, cand : list of NDV */
   
 int ndv_check_candidate(NODE input,int obpe,int oadv,EPOS oepos,NODE cand)  int ndv_check_membership(int m,NODE input,int obpe,int oadv,EPOS oepos,NODE cand)
 {  {
     int n,i,stat;      int n,i,stat;
     ND nf,d;      ND nf,d;
Line 1486  int ndv_check_candidate(NODE input,int obpe,int oadv,E
Line 1501  int ndv_check_candidate(NODE input,int obpe,int oadv,E
     Q q;      Q q;
     LIST list;      LIST list;
   
     ndv_setup(0,0,cand,GenTrace?1:0,1);      ndv_setup(m,0,cand,nd_gentrace?1:0,1);
     n = length(cand);      n = length(cand);
   
         if ( GenTrace ) { nd_alltracelist = 0; nd_tracelist = 0; }          if ( nd_gentrace ) { nd_alltracelist = 0; nd_tracelist = 0; }
     /* membercheck : list is a subset of Id(cand) ? */      /* membercheck : list is a subset of Id(cand) ? */
     for ( t = input, i = 0; t; t = NEXT(t), i++ ) {      for ( t = input, i = 0; t; t = NEXT(t), i++ ) {
 again:  again:
Line 1498  again:
Line 1513  again:
             r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos);              r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos);
         else          else
             r = (NDV)BDY(t);              r = (NDV)BDY(t);
         d = ndvtond(0,r);          d = ndvtond(m,r);
         stat = nd_nf(0,0,d,nd_ps,0,0,&nf);          stat = nd_nf(m,0,d,nd_ps,0,0,&nf);
         if ( !stat ) {          if ( !stat ) {
             nd_reconstruct(0,0);              nd_reconstruct(0,0);
             goto again;              goto again;
         } else if ( nf ) return 0;          } else if ( nf ) return 0;
                 if ( GenTrace ) {                  if ( nd_gentrace ) {
                         nd_tracelist = reverse_node(nd_tracelist);                          nd_tracelist = reverse_node(nd_tracelist);
                         MKLIST(list,nd_tracelist);                          MKLIST(list,nd_tracelist);
                         STOQ(i,q); s = mknode(2,q,list); MKLIST(list,s);                          STOQ(i,q); s = mknode(2,q,list); MKLIST(list,s);
Line 1821  int do_diagonalize(int sugar,int m)
Line 1836  int do_diagonalize(int sugar,int m)
     Q iq;      Q iq;
   
     for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {      for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {
         if ( GenTrace ) {          if ( nd_gentrace ) {
             /* Trace = [1,index,1,1] */              /* Trace = [1,index,1,1] */
             STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);              STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);
             MKLIST(l,node); MKNODE(nd_tracelist,l,0);              MKLIST(l,node); MKNODE(nd_tracelist,l,0);
Line 1837  int do_diagonalize(int sugar,int m)
Line 1852  int do_diagonalize(int sugar,int m)
         ndv_free(nfv);          ndv_free(nfv);
         hc = HCU(nf); nd_removecont(m,nf);          hc = HCU(nf); nd_removecont(m,nf);
         cont = ndc_div(m,hc,HCU(nf));          cont = ndc_div(m,hc,HCU(nf));
                 if ( GenTrace ) finalize_tracelist(i,cont);                  if ( nd_gentrace ) finalize_tracelist(i,cont);
         nfv = ndtondv(m,nf);          nfv = ndtondv(m,nf);
         nd_free(nf);          nd_free(nf);
         nd_bound[i] = ndv_compute_bound(nfv);          nd_bound[i] = ndv_compute_bound(nfv);
Line 1896  again:
Line 1911  again:
             goto again;              goto again;
         }          }
 #if USE_GEOBUCKET  #if USE_GEOBUCKET
         stat = (m&&!GenTrace)?nd_nf_pbucket(m,h,nd_ps,!Top,&nf)          stat = (m&&!nd_gentrace)?nd_nf_pbucket(m,h,nd_ps,!Top,&nf)
                :nd_nf(m,0,h,nd_ps,!Top,0,&nf);                 :nd_nf(m,0,h,nd_ps,!Top,0,&nf);
 #else  #else
         stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf);          stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf);
Line 1907  again:
Line 1922  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 1914  again:
Line 1934  again:
                 nd_monic(0,&nf);                  nd_monic(0,&nf);
                 nd_removecont(m,nf);                  nd_removecont(m,nf);
             }              }
             if ( 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;
                                 }                                  }
Line 1937  again:
Line 1957  again:
             g = update_base(g,nh);              g = update_base(g,nh);
             FREENDP(l);              FREENDP(l);
         } else {          } else {
                     if ( GenTrace && gensyz ) {                      if ( nd_gentrace && gensyz ) {
                 nd_tracelist = reverse_node(nd_tracelist);                  nd_tracelist = reverse_node(nd_tracelist);
                                 MKLIST(list,nd_tracelist);                                  MKLIST(list,nd_tracelist);
                 STOQ(-1,q); t = mknode(2,q,list); MKLIST(list,t);                  STOQ(-1,q); t = mknode(2,q,list); MKLIST(list,t);
Line 1967  int do_diagonalize_trace(int sugar,int m)
Line 1987  int do_diagonalize_trace(int sugar,int m)
     P cont,cont1;      P cont,cont1;
   
     for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {      for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {
         if ( GenTrace ) {          if ( nd_gentrace ) {
             /* Trace = [1,index,1,1] */              /* Trace = [1,index,1,1] */
             STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);              STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);
             MKLIST(l,node); MKNODE(nd_tracelist,l,0);              MKLIST(l,node); MKNODE(nd_tracelist,l,0);
Line 1994  int do_diagonalize_trace(int sugar,int m)
Line 2014  int do_diagonalize_trace(int sugar,int m)
         ndv_free(nfv);          ndv_free(nfv);
         hc = HCU(nf); nd_removecont(0,nf);          hc = HCU(nf); nd_removecont(0,nf);
                 cont = ndc_div(0,hc,HCU(nf));                  cont = ndc_div(0,hc,HCU(nf));
         if ( GenTrace ) finalize_tracelist(i,cont);          if ( nd_gentrace ) finalize_tracelist(i,cont);
         nfv = ndtondv(0,nf);          nfv = ndtondv(0,nf);
         nd_free(nf);          nd_free(nf);
         nd_bound[i] = ndv_compute_bound(nfv);          nd_bound[i] = ndv_compute_bound(nfv);
Line 2116  again:
Line 2136  again:
                     nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);                      nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq);
                     nd_removecont(m,nf); nfv = ndtondv(m,nf); nd_free(nf);                      nd_removecont(m,nf); nfv = ndtondv(m,nf); nd_free(nf);
                 }                  }
                 if ( 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;
                                    }                                     }
Line 2190  NODE ndv_reduceall(int m,NODE f)
Line 2210  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));
         if ( GenTrace ) {          if ( nd_gentrace ) {
             for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) )              for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) )
                     perm[i] = QTOS((Q)ARG1(BDY((LIST)BDY(t))));                      perm[i] = QTOS((Q)ARG1(BDY((LIST)BDY(t))));
         }          }
     for ( i = 0; i < n; ) {      for ( i = 0; i < n; ) {
         if ( GenTrace ) {          if ( nd_gentrace ) {
             /* Trace = [1,index,1,1] */              /* Trace = [1,index,1,1] */
             STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);              STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE);
             MKLIST(l,node); MKNODE(nd_tracelist,l,0);              MKLIST(l,node); MKNODE(nd_tracelist,l,0);
Line 2212  NODE ndv_reduceall(int m,NODE f)
Line 2233  NODE ndv_reduceall(int m,NODE f)
             if ( DP_Print ) { printf("."); fflush(stdout); }              if ( DP_Print ) { printf("."); fflush(stdout); }
             ndv_free(nd_ps[i]);              ndv_free(nd_ps[i]);
             hc = HCU(nf); nd_removecont(m,nf);              hc = HCU(nf); nd_removecont(m,nf);
             if ( GenTrace ) {              if ( nd_gentrace ) {
                                 for ( t = nd_tracelist; t; t = NEXT(t) ) {                                  for ( t = nd_tracelist; t; t = NEXT(t) ) {
                     jq = ARG1(BDY((LIST)BDY(t))); j = QTOS(jq);                      jq = ARG1(BDY((LIST)BDY(t))); j = QTOS(jq);
                     STOQ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq;                      STOQ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq;
Line 2228  NODE ndv_reduceall(int m,NODE f)
Line 2249  NODE ndv_reduceall(int m,NODE f)
     if ( DP_Print ) { printf("\n"); }      if ( DP_Print ) { printf("\n"); }
     for ( a0 = 0, i = 0; i < n; i++ ) {      for ( a0 = 0, i = 0; i < n; i++ ) {
         NEXTNODE(a0,a);          NEXTNODE(a0,a);
                 if ( !GenTrace ) BDY(a) = (pointer)nd_ps[i];                  if ( !nd_gentrace ) BDY(a) = (pointer)nd_ps[i];
                 else {                  else {
                         for ( j = 0; j < n; j++ ) if ( perm[j] == i ) break;                          for ( j = 0; j < n; j++ ) if ( perm[j] == i ) break;
                         BDY(a) = (pointer)nd_ps[j];                          BDY(a) = (pointer)nd_ps[j];
Line 2244  ND_pairs update_pairs( ND_pairs d, NODE /* of index */
Line 2265  ND_pairs update_pairs( ND_pairs d, NODE /* of index */
   
     if ( !g ) return d;      if ( !g ) return d;
         /* for testing */          /* for testing */
         if ( gensyz && GenSyz == 2 ) {          if ( gensyz && nd_gensyz == 2 ) {
         d1 = nd_newpairs(g,t);          d1 = nd_newpairs(g,t);
         if ( !d )          if ( !d )
          return d1;           return d1;
Line 2289  ND_pairs nd_newpairs( NODE g, int t )
Line 2310  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 2573  int ndv_newps(int m,NDV a,NDV aq)
Line 2605  int ndv_newps(int m,NDV a,NDV aq)
             nd_ps[nd_psn] = 0;              nd_ps[nd_psn] = 0;
         }          }
     }      }
     if ( GenTrace ) {      if ( nd_gentrace ) {
         /* reverse the tracelist and append it to alltracelist */          /* reverse the tracelist and append it to alltracelist */
         nd_tracelist = reverse_node(nd_tracelist); MKLIST(l,nd_tracelist);          nd_tracelist = reverse_node(nd_tracelist); MKLIST(l,nd_tracelist);
         STOQ(nd_psn,iq); tn = mknode(2,iq,l); MKLIST(l,tn);          STOQ(nd_psn,iq); tn = mknode(2,iq,l); MKLIST(l,tn);
Line 2583  int ndv_newps(int m,NDV a,NDV aq)
Line 2615  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 2638  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
Line 2671  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
             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 || !dont_removecont ) ndv_removecont(mod,a);              if ( mod || !dont_removecont ) ndv_removecont(mod,a);
             if ( !mod ) register_hcf(a);              if ( !mod ) register_hcf(a);
         }          }
         if ( GenTrace ) {          if ( nd_gentrace ) {
             STOQ(i,iq); STOQ(w[i].i,jq); node = mknode(3,iq,jq,ONE);              STOQ(i,iq); STOQ(w[i].i,jq); node = mknode(3,iq,jq,ONE);
                         if ( !dont_removecont )                          if ( !dont_removecont )
                 ARG2(node) = (pointer)ndc_div(trace?0:mod,hc,HCU(a));                  ARG2(node) = (pointer)ndc_div(trace?0:mod,hc,HCU(a));
Line 2663  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
Line 2698  void ndv_setup(int mod,int trace,NODE f,int dont_sort,
             }              }
         }          }
     }      }
     if ( 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 2771  NODE postprocess_algcoef(VL av,NODE alist,NODE r)
Line 2807  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 2785  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 2822  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;      NODE tr,tl1,tl2,tl3,tl4;
     LIST l1,l2,l3;      LIST l1,l2,l3,l4,l5;
         int j;          int j;
         Q jq;          Q jq,bpe;
     int *perm;      int *perm;
       EPOS oepos;
       int obpe,oadv,ompos,cbpe;
   
     nd_module = 0;      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);
   
     if ( DP_Multiple )      if ( DP_Multiple )
         nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);          nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);
Line 2827  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 2867  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 2843  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 2883  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
             }              }
         }          }
     nd_setup_parameters(nvar,max);      nd_setup_parameters(nvar,max);
       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) ) {
         if ( nd_module ) {          if ( nd_module ) {
                         if ( !m && !GenTrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);                          if ( !m && !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);
                         else zpl = (LIST)BDY(t);                          else zpl = (LIST)BDY(t);
             b = (pointer)pltondv(CO,vv,zpl);              b = (pointer)pltondv(CO,vv,zpl);
         } else {          } else {
                         if ( !m && !GenTrace ) ptozp((P)BDY(t),1,&dmy,&zp);                          if ( !m && !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp);
                         else zp = (P)BDY(t);                          else zp = (P)BDY(t);
             b = (pointer)ptondv(CO,vv,zp);              b = (pointer)ptondv(CO,vv,zp);
         }          }
Line 2860  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 2901  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 ( GenTrace ) {          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?1:0,0);
       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);      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;
           }
     x = ndv_reducebase(x,perm);      x = ndv_reducebase(x,perm);
     if ( GenTrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }      if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }
     x = ndv_reduceall(m,x);      x = ndv_reduceall(m,x);
       cbpe = nd_bpe;
       if ( nd_gentrace ) {
           tl2 = nd_alltracelist; nd_alltracelist = 0;
           ndv_check_membership(m,fd0,obpe,oadv,oepos,x);
           tl3 = nd_alltracelist; nd_alltracelist = 0;
           if ( nd_gensyz ) {
                   nd_gb(m,0,1,1,0);
               tl4 = nd_alltracelist; nd_alltracelist = 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 ( nalg )
         r0 = postprocess_algcoef(av,alist,r0);          r0 = postprocess_algcoef(av,alist,r0);
     MKLIST(*rp,r0);      MKLIST(*rp,r0);
     if ( GenTrace ) {      if ( nd_gentrace ) {
         tl2 = nd_alltracelist; nd_alltracelist = 0;  
         tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);          tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);
           tl3 = reverse_node(tl3);
                 /* tl2 = [[i,[[*,j,*,*],...]],...] */                  /* tl2 = [[i,[[*,j,*,*],...]],...] */
         for ( t = tl2; t; t = NEXT(t) ) {          for ( t = tl2; t; t = NEXT(t) ) {
                         /* s = [i,[*,j,*,*],...] */                          /* s = [i,[*,j,*,*],...] */
Line 2894  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
Line 2980  void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe
                 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(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3);
         tr = mknode(5,*rp,0,l1,l2,l3); MKLIST(*rp,tr);        MKLIST(l5,tl4);
             STOQ(nd_bpe,bpe);
         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 2918  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3006  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 2944  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3033  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 2970  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3059  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 2985  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
Line 3079  void nd_gr_postproc(LIST f,LIST v,int m,struct order_s
     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 3007  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3242  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);
     if ( DP_Multiple )      if ( DP_Multiple )
         nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);          nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1);
   
Line 3050  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3286  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 3070  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3306  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     ishomo = 1;      ishomo = 1;
     for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {      for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
         if ( nd_module ) {          if ( nd_module ) {
                         if ( !GenTrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);                          if ( !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl);
                         else zpl = (LIST)BDY(t);                          else zpl = (LIST)BDY(t);
             c = (pointer)pltondv(CO,vv,zpl);              c = (pointer)pltondv(CO,vv,zpl);
         } else {          } else {
                         if ( !GenTrace ) ptozp((P)BDY(t),1,&dmy,&zp);                          if ( !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp);
                         else zp = (P)BDY(t);                          else zp = (P)BDY(t);
             c = (pointer)ptondv(CO,vv,zp);              c = (pointer)ptondv(CO,vv,zp);
         }          }
Line 3100  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3336  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
             ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);              ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos);
     }      }
     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 ( 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 3121  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3359  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
         }          }
         nd_demand = 0;          nd_demand = 0;
         cand = ndv_reducebase(cand,perm);          cand = ndv_reducebase(cand,perm);
         if ( GenTrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }          if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; }
         cand = ndv_reduceall(0,cand);          cand = ndv_reduceall(0,cand);
         cbpe = nd_bpe;          cbpe = nd_bpe;
         if ( 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_candidate(in0,obpe,oadv,oepos,cand) ) {              if ( nd_gentrace ) {
             if ( GenTrace ) {  
                             tl3 = nd_alltracelist; nd_alltracelist = 0;                              tl3 = nd_alltracelist; nd_alltracelist = 0;
                     } else tl3 = 0;                      } else tl3 = 0;
             /* gbcheck : cand is a GB of Id(cand) ? */              /* gbcheck : cand is a GB of Id(cand) ? */
             ret = nd_gb(0,0,1,GenSyz?1:0,0)!=0;              ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0;
             if ( GenTrace && GenSyz ) {              if ( nd_gentrace && nd_gensyz ) {
                             tl4 = nd_alltracelist; nd_alltracelist = 0;                              tl4 = nd_alltracelist; nd_alltracelist = 0;
                     } else tl4 = 0;                      } else tl4 = 0;
                 }                  }
Line 3168  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3406  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
     if ( nalg )      if ( nalg )
         cand = postprocess_algcoef(av,alist,cand);          cand = postprocess_algcoef(av,alist,cand);
     MKLIST(*rp,cand);      MKLIST(*rp,cand);
     if ( GenTrace ) {      if ( nd_gentrace ) {
         tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);          tl1 = reverse_node(tl1); tl2 = reverse_node(tl2);
                 tl3 = reverse_node(tl3);                  tl3 = reverse_node(tl3);
                 /* tl2 = [[i,[[*,j,*,*],...]],...] */                  /* tl2 = [[i,[[*,j,*,*],...]],...] */
Line 3186  void nd_gr_trace(LIST f,LIST v,int trace,int homo,int 
Line 3424  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,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 3410  void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos
Line 3649  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 3914  int nd_sp(int mod,int trace,ND_pairs p,ND *rp)
Line 4153  int nd_sp(int mod,int trace,ND_pairs p,ND *rp)
     }      }
     t1 = ndv_mul_nm(mod,m1,p1); t2 = ndv_mul_nm(mod,m2,p2);      t1 = ndv_mul_nm(mod,m1,p1); t2 = ndv_mul_nm(mod,m2,p2);
     *rp = nd_add(mod,t1,t2);      *rp = nd_add(mod,t1,t2);
     if ( GenTrace ) {      if ( nd_gentrace ) {
         /* nd_tracelist is initialized */          /* nd_tracelist is initialized */
         STOQ(p->i1,iq); nmtodp(mod,m1,&d); node = mknode(4,ONE,iq,d,ONE);          STOQ(p->i1,iq); nmtodp(mod,m1,&d); node = mknode(4,ONE,iq,d,ONE);
         MKLIST(hist,node); MKNODE(nd_tracelist,hist,0);          MKLIST(hist,node); MKNODE(nd_tracelist,hist,0);
Line 4014  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4253  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 4069  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4310  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 4081  void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta
Line 4324  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 4598  ND ndvtond(int mod,NDV p)
Line 4843  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;
   }
   
 void ndv_print(NDV p)  void ndv_print(NDV p)
 {  {
     NMV m;      NMV m;
Line 4720  void nd_init_ord(struct order_spec *ord)
Line 4986  void nd_init_ord(struct order_spec *ord)
         /* module order */          /* module order */
         case 256:          case 256:
             nd_ispot = ord->ispot;              nd_ispot = ord->ispot;
               nd_pot_nelim = ord->pot_nelim;
             nd_dcomp = -1;              nd_dcomp = -1;
             switch ( ord->ord.simple ) {              switch ( ord->ord.simple ) {
                 case 0:                  case 0:
Line 4740  void nd_init_ord(struct order_spec *ord)
Line 5007  void nd_init_ord(struct order_spec *ord)
             break;              break;
         case 257:          case 257:
             /* block order */              /* block order */
               nd_ispot = ord->ispot;
               nd_pot_nelim = ord->pot_nelim;
               nd_dcomp = -1;
               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_ispot = ord->ispot;
               nd_pot_nelim = ord->pot_nelim;
               nd_dcomp = -1;
               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_ispot = ord->ispot;
               nd_pot_nelim = ord->pot_nelim;
               nd_dcomp = -1;
               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 4838  EPOS nd_create_epos(struct order_spec *ord)
Line 5117  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 4856  void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec
Line 5136  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 4965  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
Line 5246  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
     UINT *v,*ivi,*s0v;      UINT *v,*ivi,*s0v;
     int i,j,len,prev,diff,cdiff;      int i,j,len,prev,diff,cdiff;
     IndArray r;      IndArray r;
   struct oEGT eg0,eg1;
   
     m = pair->mul;      m = pair->mul;
     d = DL(m);      d = DL(m);
Line 4972  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
Line 5254  IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0
     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++ );          for ( ; !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 5357  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
Line 5641  int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI
     return col;      return col;
 }  }
   
   
 NODE nd_f4(int m,int **indp)  NODE nd_f4(int m,int **indp)
 {  {
     int i,nh,stat,index;      int i,nh,stat,index;
Line 5538  NODE nd_f4_trace(int m,int **indp)
Line 5823  NODE nd_f4_trace(int m,int **indp)
     return g;      return g;
 }  }
   
   NODE nd_f4_pseudo_trace(int m,int **indp)
   {
       int i,nh,stat,index;
       NODE r,g;
       ND_pairs d,l,l0,t;
       ND spol,red;
       NDV nf,redv,nfqv,nfv;
       NM s0,s;
       NODE rp0,srp0,nflist;
       int nsp,nred,col,rank,len,k,j,a;
       UINT c;
       UINT **spmat;
       UINT *s0vect,*svect,*p,*v;
       int *colstat;
       IndArray *imat;
       int *rhead;
       int spcol,sprow;
       int sugar;
       PGeoBucket bucket;
       struct oEGT eg0,eg1,eg_f4;
   
       g = 0; d = 0;
       for ( i = 0; i < nd_psn; i++ ) {
           d = update_pairs(d,g,i,0);
           g = update_base(g,i);
       }
       while ( d ) {
           get_eg(&eg0);
           l = nd_minsugarp(d,&d);
           sugar = SG(l);
           bucket = create_pbucket();
           stat = nd_sp_f4(m,0,l,bucket);
           if ( !stat ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           if ( bucket->m < 0 ) continue;
           col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0);
           if ( !col ) {
               for ( t = l; NEXT(t); t = NEXT(t) );
               NEXT(t) = d; d = l;
               d = nd_reconstruct(1,d);
               continue;
           }
           get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1);
           if ( DP_Print )
               fprintf(asir_out,"sugar=%d,symb=%fsec,",
                   sugar,eg_f4.exectime+eg_f4.gctime);
           nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0);
           if ( !l0 ) continue;
           l = l0;
   
           /* over Q */
                   while ( 1 ) {
                   bucket = create_pbucket();
                   stat = nd_sp_f4(0,1,l,bucket);
                   if ( !stat ) {
                   for ( t = l; NEXT(t); t = NEXT(t) );
                   NEXT(t) = d; d = l;
                   d = nd_reconstruct(1,d);
                   continue;
                   }
                   if ( bucket->m < 0 ) continue;
                   col = nd_symbolic_preproc(bucket,1,&s0vect,&rp0);
                   if ( !col ) {
                   for ( t = l; NEXT(t); t = NEXT(t) );
                   NEXT(t) = d; d = l;
                   d = nd_reconstruct(1,d);
                   continue;
                   }
                   nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0);
                   }
   
           /* adding new bases */
           for ( r = nflist; r; r = NEXT(r) ) {
               nfqv = (NDV)BDY(r);
               ndv_removecont(0,nfqv);
               if ( !rem(NM(HCQ(nfqv)),m) ) return 0;
               if ( nd_nalg ) {
                   ND nf1;
   
                   nf1 = ndvtond(m,nfqv);
                   nd_monic(0,&nf1);
                   nd_removecont(0,nf1);
                   nfqv = ndtondv(0,nf1); nd_free(nf1);
               }
               nfv = ndv_dup(0,nfqv);
               ndv_mod(m,nfv);
               ndv_removecont(m,nfv);
               nh = ndv_newps(0,nfv,nfqv);
               d = update_pairs(d,g,nh,0);
               g = update_base(g,nh);
           }
       }
   #if 0
       fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);
   #endif
           conv_ilist(0,1,g,indp);
       return g;
   }
   
 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 5546  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
Line 5934  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;
   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 5564  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
Line 5952  NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve
         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_q_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);
   print_eg("search",&eg_search);
     return r0;      return r0;
 }  }
   
Line 6046  void nd_exec_f4_red_dist()
Line 6435  void nd_exec_f4_red_dist()
   
 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 6080  int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co
Line 6451  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);  
     if ( SGN(dn) < 0 ) inv = mod-inv;  
     for ( i = 0; i < row; i++ )  
         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;  
             } else  
                 t = 0;  
             c = dmar(t,inv,0,mod);  
             if ( wmat[i][j] != c )  
                 error("afo");  
         }  
     return rank;      return rank;
 }  }
   
Line 6380  void nd_det(int mod,MAT f,P *rp)
Line 6738  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 6388  void nd_det(int mod,MAT f,P *rp)
Line 6746  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 6748  void finalize_tracelist(int i,P cont)
Line 7106  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 6773  void conv_ilist(int demand,int trace,NODE g,int **indp
Line 7131  void conv_ilist(int demand,int trace,NODE g,int **indp
                 BDY(t) = (pointer)(demand?ndv_load(j):(trace?nd_ps_trace[j]:nd_ps[j]));                  BDY(t) = (pointer)(demand?ndv_load(j):(trace?nd_ps_trace[j]:nd_ps[j]));
         }          }
         if ( indp ) *indp = ind;          if ( indp ) *indp = ind;
   }
   
   void parse_nd_option(NODE opt)
   {
       NODE t,p,u;
           int i,s;
       char *key;
       Obj value;
   
       nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0;
           nd_newelim = 0; nd_intersect = 0;
       for ( t = opt; t; t = NEXT(t) ) {
           p = BDY((LIST)BDY(t));
           key = BDY((STRING)BDY(p));
           value = (Obj)BDY(NEXT(p));
           if ( !strcmp(key,"gentrace") )
               nd_gentrace = value?1:0;
           else if ( !strcmp(key,"gensyz") )
               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;
       }
 }  }
Legend:
Removed from v.1.168  
changed lines
  Added in v.1.199
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>