[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.45 and 1.54

version 1.45, 2003/08/25 08:57:31 version 1.54, 2003/08/31 07:42:23
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.44 2003/08/22 08:32:51 noro Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.53 2003/08/29 07:37:30 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 271  void nd_reconstruct_direct(int mod,NDV *ps,int len);
Line 271  void nd_reconstruct_direct(int mod,NDV *ps,int len);
 void nd_setup(int mod,int trace,NODE f);  void nd_setup(int mod,int trace,NODE f);
 void nd_setup_parameters();  void nd_setup_parameters();
 BlockMask nd_create_blockmask(struct order_spec *ord);  BlockMask nd_create_blockmask(struct order_spec *ord);
   int nd_get_exporigin(struct order_spec *ord);
   
 /* ND functions */  /* ND functions */
 int nd_check_candidate(NODE input,NODE cand);  int nd_check_candidate(NODE input,NODE cand);
Line 1037  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 1067  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 1105  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 1148  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 1300  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 1493  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 1511  again:
Line 1510  again:
                 } else if ( nf ) {                  } else if ( nf ) {
                         if ( checkonly ) return 0;                          if ( checkonly ) return 0;
                         printf("+"); fflush(stdout);                          printf("+"); fflush(stdout);
                         nh = m?nd_newps(m,nf,0):nd_newps(m,0,nf);                          nh = nd_newps(m,nf,0);
                         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 1520  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 1548  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 1565  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 1583  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 1609  NODE nd_reduceall(int m,NODE f)
Line 1605  NODE nd_reduceall(int m,NODE f)
         for ( n = 0, t = f; t; t = NEXT(t), n++ );          for ( n = 0, t = f; t; t = NEXT(t), n++ );
         ps = (NDV *)ALLOCA(n*sizeof(NDV));          ps = (NDV *)ALLOCA(n*sizeof(NDV));
         bound = (unsigned int **)ALLOCA(n*sizeof(unsigned int *));          bound = (unsigned int **)ALLOCA(n*sizeof(unsigned int *));
         for ( i = 0, t = f; i < n; i++, t = NEXT(t) ) {          for ( i = 0, t = f; i < n; i++, t = NEXT(t) ) ps[i] = (NDV)BDY(t);
                 ps[i] = (NDV)BDY(t);  
                 bound[i] = ndv_compute_bound(ps[i]);  
         }  
         qsort(ps,n,sizeof(NDV),(int (*)(const void *,const void *))ndv_compare);          qsort(ps,n,sizeof(NDV),(int (*)(const void *,const void *))ndv_compare);
           for ( i = 0; i < n; i++ ) bound[i] = ndv_compute_bound(ps[i]);
         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 1627  again:
Line 1621  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 1643  again:
Line 1638  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 1896  int nd_newps(int mod,ND a,ND aq)
Line 1892  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 1939  void nd_setup(int mod,int trace,NODE f)
Line 1932  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 1965  void nd_setup(int mod,int trace,NODE f)
Line 1958  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 1998  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
Line 1988  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 2013  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
Line 2004  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 2035  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2037  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 2047  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2046  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 2073  void nd_gr_trace(LIST f,LIST v,int m,int homo,struct o
Line 2087  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 2346  void ndv_dehomogenize(NDV p,struct order_spec *ord)
Line 2369  void ndv_dehomogenize(NDV p,struct order_spec *ord)
   
         len = p->len;          len = p->len;
         newnvar = nd_nvar-1;          newnvar = nd_nvar-1;
         newexporigin = ord->ord.block.length+1;          newexporigin = nd_get_exporigin(ord);
         newwpd = newnvar/nd_epw+(newnvar%nd_epw?1:0)+newexporigin;          newwpd = newnvar/nd_epw+(newnvar%nd_epw?1:0)+newexporigin;
         for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ )          for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ )
                 ndl_dehomogenize(DL(m));                  ndl_dehomogenize(DL(m));
Line 2502  unsigned int *ndv_compute_bound(NDV p)
Line 2525  unsigned int *ndv_compute_bound(NDV p)
         return t;          return t;
 }  }
   
 void nd_setup_parameters() {  int nd_get_exporigin(struct order_spec *ord)
         int i,n,elen;  {
           switch ( ord->id ) {
         nd_epw = (sizeof(unsigned int)*8)/nd_bpe;  
         elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0);  
   
         switch ( nd_ord->id ) {  
                 case 0:                  case 0:
                         nd_exporigin = 1;                          return 1;
                         break;  
                 case 1:                  case 1:
                         /* block order */                          /* block order */
                         /* 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) */
                         nd_exporigin = nd_ord->ord.block.length+1;                          return ord->ord.block.length+1;
                         break;  
                 case 2:                  case 2:
                         error("nd_setup_parameters : matrix order is not supported yet.");                          error("nd_get_exporigin : matrix order is not supported yet.");
                         break;  
         }          }
   }
   
   void nd_setup_parameters() {
           int i,n,elen;
   
           nd_epw = (sizeof(unsigned int)*8)/nd_bpe;
           elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0);
   
           nd_exporigin = nd_get_exporigin(nd_ord);
         nd_wpd = nd_exporigin+elen;          nd_wpd = nd_exporigin+elen;
         nd_epos = (EPOS)MALLOC_ATOMIC(nd_nvar*sizeof(struct oEPOS));          nd_epos = (EPOS)MALLOC_ATOMIC(nd_nvar*sizeof(struct oEPOS));
         for ( i = 0; i < nd_nvar; i++ ) {          for ( i = 0; i < nd_nvar; i++ ) {
Line 2568  ND_pairs nd_reconstruct(int mod,int trace,ND_pairs d)
Line 2593  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 2708  ND nd_copy(ND p)
Line 2733  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 2716  int nd_sp(int mod,ND_pairs p,ND *rp)
Line 2741  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);
Line 2878  NDV dptondv(int mod,DP p)
Line 2903  NDV dptondv(int mod,DP p)
         DP q;          DP q;
         int l,i,n;          int l,i,n;
   
         if ( !p ) return 0;  
         for ( t = BDY(p), l = 0; t; t = NEXT(t), l++ );  
         if ( mod ) {          if ( mod ) {
                 _dp_mod(p,mod,0,&q); p = q;                  _dp_mod(p,mod,0,&q); p = q;
           }
           if ( !p ) return 0;
           for ( t = BDY(p), l = 0; t; t = NEXT(t), l++ );
           if ( mod )
                 m0 = m = (NMV)MALLOC_ATOMIC(l*nmv_adv);                  m0 = m = (NMV)MALLOC_ATOMIC(l*nmv_adv);
         } else          else
                 m0 = m = (NMV)MALLOC(l*nmv_adv);                  m0 = m = (NMV)MALLOC(l*nmv_adv);
         n = NV(p);          n = NV(p);
         for ( t = BDY(p); t; i++, t = NEXT(t), NMV_ADV(m) ) {          for ( t = BDY(p); t; t = NEXT(t), NMV_ADV(m) ) {
                 if ( mod ) CM(m) = ITOS(C(t));                  if ( mod ) CM(m) = ITOS(C(t));
                 else CQ(m) = (Q)C(t);                  else CQ(m) = (Q)C(t);
                 dltondl(n,DL(t),DL(m));                  dltondl(n,DL(t),DL(m));
Legend:
Removed from v.1.45  
changed lines
  Added in v.1.54
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>