[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.48 and 1.53

version 1.48, 2003/08/26 01:42:12 version 1.53, 2003/08/29 07:37:30
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.47 2003/08/25 09:19:43 noro Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.52 2003/08/27 02:21:16 noro Exp $ */
   
 #include "ca.h"  #include "ca.h"
 #include "inline.h"  #include "inline.h"
Line 109  static ND _nd_free_list;
Line 109  static ND _nd_free_list;
 static ND_pairs _ndp_free_list;  static ND_pairs _ndp_free_list;
   
 static NDV *nd_ps;  static NDV *nd_ps;
 static NDV *nd_psq;  static NDV *nd_ps_trace;
 static RHist *nd_psh;  static RHist *nd_psh;
 static int nd_psn,nd_pslen;  static int nd_psn,nd_pslen;
   
Line 218  int crit_2( int dp1, int dp2 );
Line 218  int crit_2( int dp1, int dp2 );
   
 /* top level functions */  /* top level functions */
 void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp);  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp);
 void nd_gr_trace(LIST f,LIST v,int m,int homo,struct order_spec *ord,LIST *rp);  void nd_gr_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp);
 NODE nd_gb(int m,int checkonly);  NODE nd_gb(int m,int checkonly);
 NODE nd_gb_trace(int m);  NODE nd_gb_trace(int m);
   
Line 239  INLINE int ndl_hash_value(unsigned int *d);
Line 239  INLINE int ndl_hash_value(unsigned int *d);
 /* normal forms */  /* normal forms */
 INLINE int nd_find_reducer(ND g);  INLINE int nd_find_reducer(ND g);
 INLINE int nd_find_reducer_direct(ND g,NDV *ps,int len);  INLINE int nd_find_reducer_direct(ND g,NDV *ps,int len);
 int nd_sp(int mod,ND_pairs p,ND *nf);  int nd_sp(int mod,int trace,ND_pairs p,ND *nf);
 int nd_nf(int mod,ND g,int full,ND *nf);  int nd_nf(int mod,ND g,NDV *ps,int full,ND *nf);
 int nd_nf_pbucket(int mod,ND g,int full,ND *nf);  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *nf);
 int nd_nf_direct(int mod,ND g,BaseSet base,int full,ND *rp);  int nd_nf_direct(int mod,ND g,BaseSet base,int full,ND *rp);
   
 /* finalizers */  /* finalizers */
Line 1038  ND nd_add_q(ND p1,ND p2)
Line 1038  ND nd_add_q(ND p1,ND p2)
 }  }
   
 /* ret=1 : success, ret=0 : overflow */  /* ret=1 : success, ret=0 : overflow */
 int nd_nf(int mod,ND g,int full,ND *rp)  int nd_nf(int mod,ND g,NDV *ps,int full,ND *rp)
 {  {
         ND d;          ND d;
         NM m,mrd,tail;          NM m,mrd,tail;
Line 1068  int nd_nf(int mod,ND g,int full,ND *rp)
Line 1068  int nd_nf(int mod,ND g,int full,ND *rp)
                                 nd_free(g); nd_free(d);                                  nd_free(g); nd_free(d);
                                 return 0;                                  return 0;
                         }                          }
                           p = ps[index];
                         if ( mod ) {                          if ( mod ) {
                                 p = nd_ps[index];  
                                 c1 = invm(HCM(p),mod); c2 = mod-HCM(g);                                  c1 = invm(HCM(p),mod); c2 = mod-HCM(g);
                                 DMAR(c1,c2,0,mod,c); CM(mul) = c;                                  DMAR(c1,c2,0,mod,c); CM(mul) = c;
                         } else {                          } else {
                                 p = nd_psq[index];  
                                 igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);                                  igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);
                                 chsgnq(cg,&CQ(mul));                                  chsgnq(cg,&CQ(mul));
                                 nd_mul_c_q(d,cred); nd_mul_c_q(g,cred);                                  nd_mul_c_q(d,cred); nd_mul_c_q(g,cred);
Line 1106  int nd_nf(int mod,ND g,int full,ND *rp)
Line 1105  int nd_nf(int mod,ND g,int full,ND *rp)
         return 1;          return 1;
 }  }
   
 int nd_nf_pbucket(int mod,ND g,int full,ND *rp)  int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp)
 {  {
         int hindex,index;          int hindex,index;
         NDV p;          NDV p;
Line 1149  int nd_nf_pbucket(int mod,ND g,int full,ND *rp)
Line 1148  int nd_nf_pbucket(int mod,ND g,int full,ND *rp)
                                 *rp = 0;                                  *rp = 0;
                                 return 0;                                  return 0;
                         }                          }
                           p = ps[index];
                         if ( mod ) {                          if ( mod ) {
                                 p = nd_ps[index];  
                                 c1 = invm(HCM(p),mod); c2 = mod-HCM(g);                                  c1 = invm(HCM(p),mod); c2 = mod-HCM(g);
                                 DMAR(c1,c2,0,mod,c); CM(mul) = c;                                  DMAR(c1,c2,0,mod,c); CM(mul) = c;
                         } else {                          } else {
                                 p = nd_psq[index];  
                                 igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);                                  igcd_cofactor(HCQ(g),HCQ(p),&gcd,&cg,&cred);
                                 chsgnq(cg,&CQ(mul));                                  chsgnq(cg,&CQ(mul));
                                 nd_mul_c_q(d,cred);                                  nd_mul_c_q(d,cred);
Line 1301  int nd_check_candidate(NODE input,NODE cand)
Line 1299  int nd_check_candidate(NODE input,NODE cand)
         for ( t = input; t; t = NEXT(t) ) {          for ( t = input; t; t = NEXT(t) ) {
 again:  again:
                 d = dptond(0,(DP)BDY(t));                  d = dptond(0,(DP)BDY(t));
                 stat = nd_nf(0,d,0,&nf);                  stat = nd_nf(0,d,nd_ps,0,&nf);
                 if ( !stat ) {                  if ( !stat ) {
                         nd_reconstruct(0,0,0);                          nd_reconstruct(0,0,0);
                         goto again;                          goto again;
Line 1494  again:
Line 1492  again:
                         sugar = SG(l);                          sugar = SG(l);
                         fprintf(asir_out,"%d",sugar);                          fprintf(asir_out,"%d",sugar);
                 }                  }
                 stat = nd_sp(m,l,&h);                  stat = nd_sp(m,0,l,&h);
                 if ( !stat ) {                  if ( !stat ) {
                         NEXT(l) = d; d = l;                          NEXT(l) = d; d = l;
                         d = nd_reconstruct(m,0,d);                          d = nd_reconstruct(m,0,d);
                         goto again;                          goto again;
                 }                  }
 #if USE_GEOBUCKET  #if USE_GEOBUCKET
                 stat = m?nd_nf_pbucket(m,h,!Top,&nf):nd_nf(m,h,!Top,&nf);                  stat = m?nd_nf_pbucket(m,h,nd_ps,!Top,&nf):nd_nf(m,h,nd_ps,!Top,&nf);
 #else  #else
                 stat = nd_nf(m,h,!Top,&nf);                  stat = nd_nf(m,h,nd_ps,!Top,&nf);
 #endif  #endif
                 if ( !stat ) {                  if ( !stat ) {
                         NEXT(l) = d; d = l;                          NEXT(l) = d; d = l;
Line 1512  again:
Line 1510  again:
                 } else if ( nf ) {                  } else if ( nf ) {
                         if ( checkonly ) return 0;                          if ( checkonly ) return 0;
                         printf("+"); fflush(stdout);                          printf("+"); fflush(stdout);
                         ndl_print(HDL(nf));                          nh = nd_newps(m,nf,0);
                         nh = m?nd_newps(m,nf,0):nd_newps(m,0,nf);  
                         d = update_pairs(d,g,nh);                          d = update_pairs(d,g,nh);
                         g = update_base(g,nh);                          g = update_base(g,nh);
                         FREENDP(l);                          FREENDP(l);
Line 1522  again:
Line 1519  again:
                         FREENDP(l);                          FREENDP(l);
                 }                  }
         }          }
         if ( m )          for ( t = g; t; t = NEXT(t) ) BDY(t) = (pointer)nd_ps[(int)BDY(t)];
                 for ( t = g; t; t = NEXT(t) ) BDY(t) = (pointer)nd_ps[(int)BDY(t)];  
         else  
                 for ( t = g; t; t = NEXT(t) ) BDY(t) = (pointer)nd_psq[(int)BDY(t)];  
         return g;          return g;
 }  }
   
Line 1550  again:
Line 1544  again:
                         sugar = SG(l);                          sugar = SG(l);
                         fprintf(asir_out,"%d",sugar);                          fprintf(asir_out,"%d",sugar);
                 }                  }
                 stat = nd_sp(m,l,&h);                  stat = nd_sp(m,0,l,&h);
                 if ( !stat ) {                  if ( !stat ) {
                         NEXT(l) = d; d = l;                          NEXT(l) = d; d = l;
                         d = nd_reconstruct(m,1,d);                          d = nd_reconstruct(m,1,d);
                         goto again;                          goto again;
                 }                  }
 #if USE_GEOBUCKET  #if USE_GEOBUCKET
                 stat = nd_nf_pbucket(m,h,!Top,&nf);                  stat = nd_nf_pbucket(m,h,nd_ps,!Top,&nf);
 #else  #else
                 stat = nd_nf(m,h,!Top,&nf);                  stat = nd_nf(m,h,nd_ps,!Top,&nf);
 #endif  #endif
                 if ( !stat ) {                  if ( !stat ) {
                         NEXT(l) = d; d = l;                          NEXT(l) = d; d = l;
Line 1567  again:
Line 1561  again:
                         goto again;                          goto again;
                 } else if ( nf ) {                  } else if ( nf ) {
                         /* overflow does not occur */                          /* overflow does not occur */
                         nd_sp(0,l,&h);                          nd_sp(0,1,l,&h);
                         nd_nf(0,h,!Top,&nfq);                          nd_nf(0,h,nd_ps_trace,!Top,&nfq);
                         if ( nfq ) {                          if ( nfq ) {
                                 printf("+"); fflush(stdout);                                  printf("+"); fflush(stdout);
                                 nh = nd_newps(m,nf,nfq);                                  nh = nd_newps(m,nf,nfq);
Line 1585  again:
Line 1579  again:
                 FREENDP(l);                  FREENDP(l);
         }          }
         for ( t = g; t; t = NEXT(t) )          for ( t = g; t; t = NEXT(t) )
                 BDY(t) = (pointer)nd_psq[(int)BDY(t)];                  BDY(t) = (pointer)nd_ps_trace[(int)BDY(t)];
         return g;          return g;
 }  }
   
Line 1619  NODE nd_reduceall(int m,NODE f)
Line 1613  NODE nd_reduceall(int m,NODE f)
         base.ps = (NDV *)ALLOCA((n-1)*sizeof(NDV));          base.ps = (NDV *)ALLOCA((n-1)*sizeof(NDV));
         base.bound = (unsigned int **)ALLOCA((n-1)*sizeof(unsigned int *));          base.bound = (unsigned int **)ALLOCA((n-1)*sizeof(unsigned int *));
         base.len = n-1;          base.len = n-1;
         for ( i = 0; i < n; i++ ) {          i = 0;
 again:          while ( i < n ) {
                 for ( j = 0; j < i; j++ ) {                  for ( j = 0; j < i; j++ ) {
                         base.ps[j] = ps[j]; base.bound[j] = bound[j];                          base.ps[j] = ps[j]; base.bound[j] = bound[j];
                 }                  }
Line 1629  again:
Line 1623  again:
                 }                  }
                 g = ndvtond(m,ps[i]);                  g = ndvtond(m,ps[i]);
                 stat = nd_nf_direct(m,g,&base,1,&nf);                  stat = nd_nf_direct(m,g,&base,1,&nf);
                 if ( !stat ) {                  if ( !stat )
                         nd_reconstruct_direct(m,ps,n);                          nd_reconstruct_direct(m,ps,n);
                         goto again;  
                 }  
                 else if ( !nf ) {                  else if ( !nf ) {
                         printf("."); fflush(stdout);                          printf("."); fflush(stdout);
                         ndv_free(ps[i]);                          ndv_free(ps[i]);
                         for ( j = i+1; j < n; j++ ) ps[j-1] = ps[j];                          for ( j = i+1; j < n; j++ ) {
                                   ps[j-1] = ps[j]; bound[j-1] = bound[j];
                           }
                         n--;                          n--;
                           base.len = n-1;
                 } else {                  } else {
                         printf("."); fflush(stdout);                          printf("."); fflush(stdout);
                         ndv_free(ps[i]);                          ndv_free(ps[i]);
Line 1645  again:
Line 1640  again:
                         ps[i] = ndtondv(m,nf);                          ps[i] = ndtondv(m,nf);
                         bound[i] = ndv_compute_bound(ps[i]);                          bound[i] = ndv_compute_bound(ps[i]);
                         nd_free(nf);                          nd_free(nf);
                           i++;
                 }                  }
         }          }
         printf("\n");          printf("\n");
Line 1898  int nd_newps(int mod,ND a,ND aq)
Line 1894  int nd_newps(int mod,ND a,ND aq)
         RHist r;          RHist r;
         NDV b;          NDV b;
   
           if ( aq ) {
                   /* trace lifting */
                   if ( !rem(NM(HCQ(aq)),mod) )
                           return -1;
           }
         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_psq = (NDV *)REALLOC((char *)nd_psq,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 = (unsigned int **)                  nd_bound = (unsigned int **)
                         REALLOC((char *)nd_bound,nd_pslen*sizeof(unsigned int *));                          REALLOC((char *)nd_bound,nd_pslen*sizeof(unsigned int *));
         }          }
         if ( a && aq ) {  
                 /* trace lifting */  
                 if ( !rem(NM(HCQ(aq)),mod) )  
                         return -1;  
         }  
         NEWRHist(r); nd_psh[nd_psn] = r;          NEWRHist(r); nd_psh[nd_psn] = r;
           nd_removecont(mod,a); nd_ps[nd_psn] = ndtondv(mod,a);
         if ( aq ) {          if ( aq ) {
                 nd_removecont(0,aq);                  nd_removecont(0,aq); nd_ps_trace[nd_psn] = ndtondv(0,aq);
                 nd_psq[nd_psn] = ndtondv(0,aq);                  nd_bound[nd_psn] = ndv_compute_bound(nd_ps_trace[nd_psn]);
                 nd_bound[nd_psn] = ndv_compute_bound(nd_psq[nd_psn]);  
                 SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r));                  SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r));
                   nd_free(a); nd_free(aq);
           } else {
                   nd_bound[nd_psn] = ndv_compute_bound(nd_ps[nd_psn]);
                   SG(r) = SG(a); ndl_copy(HDL(a),DL(r));
                   nd_free(a);
         }          }
         if ( a ) {  
                 nd_removecont(mod,a);  
                 nd_ps[nd_psn] = ndtondv(mod,a);  
                 if ( !aq ) {  
                         nd_bound[nd_psn] = ndv_compute_bound(nd_ps[nd_psn]);  
                         SG(r) = SG(a); ndl_copy(HDL(a),DL(r));  
                 }  
         }  
         nd_free(a); nd_free(aq);  
         return nd_psn++;          return nd_psn++;
 }  }
   
Line 1942  void nd_setup(int mod,int trace,NODE f)
Line 1934  void nd_setup(int mod,int trace,NODE f)
   
         nd_psn = length(f); nd_pslen = 2*nd_psn;          nd_psn = length(f); nd_pslen = 2*nd_psn;
         nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));          nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
         nd_psq = (NDV *)MALLOC(nd_pslen*sizeof(NDV));          nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));
         nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));          nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));
         nd_bound = (unsigned int **)MALLOC(nd_pslen*sizeof(unsigned int *));          nd_bound = (unsigned int **)MALLOC(nd_pslen*sizeof(unsigned int *));
         for ( max = 0, i = 0, s = f; i < nd_psn; i++, s = NEXT(s) ) {          for ( max = 0, i = 0, s = f; i < nd_psn; i++, s = NEXT(s) ) {
Line 1968  void nd_setup(int mod,int trace,NODE f)
Line 1960  void nd_setup(int mod,int trace,NODE f)
                 a = dptondv(mod,(DP)BDY(f)); ndv_removecont(mod,a);                  a = dptondv(mod,(DP)BDY(f)); ndv_removecont(mod,a);
                 SG(r) = HTD(a); ndl_copy(HDL(a),DL(r));                  SG(r) = HTD(a); ndl_copy(HDL(a),DL(r));
   
                   nd_ps[i] = a;
                 if ( trace ) {                  if ( trace ) {
                         nd_ps[i] = a;  
                         a = dptondv(0,(DP)BDY(f)); ndv_removecont(0,a);                          a = dptondv(0,(DP)BDY(f)); ndv_removecont(0,a);
                         nd_psq[i] = a;                          nd_ps_trace[i] = a;
                 } else {  
                         if ( mod ) nd_ps[i] = a;  
                         else nd_psq[i] = a;  
                 }                  }
                 nd_psh[i] = r;                  nd_psh[i] = r;
         }          }
Line 2001  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
Line 1990  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
         x = nd_gb(m,0);          x = nd_gb(m,0);
         fprintf(asir_out,"found=%d,notfirst=%d,create=%d\n",          fprintf(asir_out,"found=%d,notfirst=%d,create=%d\n",
                 nd_found,nd_notfirst,nd_create);                  nd_found,nd_notfirst,nd_create);
           x = nd_reducebase(x);
         x = nd_reduceall(m,x);          x = nd_reduceall(m,x);
         for ( r0 = 0, t = x; t; t = NEXT(t) ) {          for ( r0 = 0, t = x; t; t = NEXT(t) ) {
                 NEXTNODE(r0,r);                  NEXTNODE(r0,r);
Line 2016  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
Line 2006  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
         MKLIST(*rp,r0);          MKLIST(*rp,r0);
 }  }
   
 void nd_gr_trace(LIST f,LIST v,int m,int homo,struct order_spec *ord,LIST *rp)  void nd_gr_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp)
 {  {
         struct order_spec ord1;          struct order_spec ord1;
         VL fv,vv,vc;          VL fv,vv,vc;
         NODE fd,fd0,in0,in,r,r0,t,s,cand;          NODE fd,fd0,in0,in,r,r0,t,s,cand;
           int m,nocheck,nvar,mindex;
         DP a,b,c,h;          DP a,b,c,h;
         P p;          P p;
   
         get_vars((Obj)f,&fv); pltovl(v,&vv);          get_vars((Obj)f,&fv); pltovl(v,&vv);
         nd_nvar = length(vv);          nvar = length(vv);
           nocheck = 0;
           mindex = 0;
   
           /* setup modulus */
           if ( trace < 0 ) {
                   trace = -trace;
                   nocheck = 1;
           }
           m = trace > 1 ? trace : get_lprime(mindex);
   
         initd(ord);          initd(ord);
         if ( homo ) {          if ( homo ) {
                 homogenize_order(ord,nd_nvar,&ord1);                  homogenize_order(ord,nd_nvar,&ord1);
Line 2038  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2039  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
                 }                  }
                 if ( fd0 ) NEXT(fd) = 0;                  if ( fd0 ) NEXT(fd) = 0;
                 if ( in0 ) NEXT(in) = 0;                  if ( in0 ) NEXT(in) = 0;
                 nd_init_ord(&ord1);  
                 initd(&ord1);  
                 nd_nvar++;  
         } else {          } else {
                 for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {                  for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
                         ptod(CO,vv,(P)BDY(t),&c);                          ptod(CO,vv,(P)BDY(t),&c);
Line 2050  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2048  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
                 }                  }
                 if ( fd0 ) NEXT(fd) = 0;                  if ( fd0 ) NEXT(fd) = 0;
                 in0 = fd0;                  in0 = fd0;
                 nd_init_ord(ord);  
         }          }
         do {          while ( 1 ) {
                   if ( homo ) {
                           nd_init_ord(&ord1);
                           initd(&ord1);
                           nd_nvar = nvar+1;
                   } else {
                           nd_init_ord(ord);
                           nd_nvar = nvar;
                   }
                 nd_setup(m,1,fd0);                  nd_setup(m,1,fd0);
                 cand = nd_gb_trace(m);                  cand = nd_gb_trace(m);
                 if ( !cand ) continue;                  if ( !cand ) {
                           /* failure */
                           if ( trace > 1 ) {
                                   *rp = 0; return;
                           } else
                                   m = get_lprime(++mindex);
                           continue;
                   }
   
                 if ( homo ) {                  if ( homo ) {
                         /* dehomogenization */                          /* dehomogenization */
                         for ( t = cand; t; t = NEXT(t) )                          for ( t = cand; t; t = NEXT(t) )
                                 ndv_dehomogenize((NDV)BDY(t),ord);                                  ndv_dehomogenize((NDV)BDY(t),ord);
                         nd_nvar--;                          nd_nvar = nvar;
                         initd(ord);                          initd(ord);
                         nd_init_ord(ord);                          nd_init_ord(ord);
                         nd_setup_parameters();                          nd_setup_parameters();
                         cand = nd_reducebase(cand);  
                 }                  }
                   cand = nd_reducebase(cand);
                 fprintf(asir_out,"found=%d,notfirst=%d,create=%d\n",                  fprintf(asir_out,"found=%d,notfirst=%d,create=%d\n",
                         nd_found,nd_notfirst,nd_create);                          nd_found,nd_notfirst,nd_create);
                 cand = nd_reduceall(0,cand);                  cand = nd_reduceall(0,cand);
Line 2076  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2089  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
                 }                  }
                 if ( r0 ) NEXT(r) = 0;                  if ( r0 ) NEXT(r) = 0;
                 cand = r0;                  cand = r0;
         } while ( !nd_check_candidate(in0,cand) );                  if ( nocheck || nd_check_candidate(in0,cand) )
                           /* success */
                           break;
                   else if ( trace > 1 ) {
                           /* failure */
                           *rp = 0; return;
                   } else
                           /* try the next modulus */
                           m = get_lprime(++mindex);
           }
         /* dp->p */          /* dp->p */
         for ( r = cand; r; r = NEXT(r) ) {          for ( r = cand; r; r = NEXT(r) ) {
                 dtop(CO,vv,BDY(r),&p);                  dtop(CO,vv,BDY(r),&p);
Line 2507  unsigned int *ndv_compute_bound(NDV p)
Line 2529  unsigned int *ndv_compute_bound(NDV p)
   
 int nd_get_exporigin(struct order_spec *ord)  int nd_get_exporigin(struct order_spec *ord)
 {  {
         switch ( nd_ord->id ) {          switch ( ord->id ) {
                 case 0:                  case 0:
                         return 1;                          return 1;
                 case 1:                  case 1:
Line 2515  int nd_get_exporigin(struct order_spec *ord)
Line 2537  int nd_get_exporigin(struct order_spec *ord)
                         /* d[0]:weight d[1]:w0,...,d[nd_exporigin-1]:w(n-1) */                          /* d[0]:weight d[1]:w0,...,d[nd_exporigin-1]:w(n-1) */
                         return ord->ord.block.length+1;                          return ord->ord.block.length+1;
                 case 2:                  case 2:
                         error("nd_setup_parameters : matrix order is not supported yet.");                          error("nd_get_exporigin : matrix order is not supported yet.");
         }          }
 }  }
   
Line 2573  ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)
Line 2595  ND_pairs nd_reconstruct(int mod,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;
         if ( mod != 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);          if ( trace )
         if ( !mod || trace )                  for ( i = nd_psn-1; i >= 0; i-- )
                 for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_psq[i],obpe,oadv,oepos);                          ndv_realloc(nd_ps_trace[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 2713  ND nd_copy(ND p)
Line 2735  ND nd_copy(ND p)
         }          }
 }  }
   
 int nd_sp(int mod,ND_pairs p,ND *rp)  int nd_sp(int mod,int trace,ND_pairs p,ND *rp)
 {  {
         NM m;          NM m;
         NDV p1,p2;          NDV p1,p2;
Line 2721  int nd_sp(int mod,ND_pairs p,ND *rp)
Line 2743  int nd_sp(int mod,ND_pairs p,ND *rp)
         unsigned int *lcm;          unsigned int *lcm;
         int td;          int td;
   
         if ( mod ) {          if ( trace ) {
                 p1 = nd_ps[p->i1]; p2 = nd_ps[p->i2];                  p1 = nd_ps_trace[p->i1]; p2 = nd_ps_trace[p->i2];
         } else {          } else {
                 p1 = nd_psq[p->i1]; p2 = nd_psq[p->i2];                  p1 = nd_ps[p->i1]; p2 = nd_ps[p->i2];
         }          }
         lcm = LCM(p);          lcm = LCM(p);
         NEWNM(m);          NEWNM(m);
Legend:
Removed from v.1.48  
changed lines
  Added in v.1.53
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>