[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.52

version 1.48, 2003/08/26 01:42:12 version 1.52, 2003/08/27 02:21:16
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.51 2003/08/27 01:53:29 noro Exp $ */
   
 #include "ca.h"  #include "ca.h"
 #include "inline.h"  #include "inline.h"
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 1512  again:
Line 1512  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 = m?nd_newps(m,nf,0):nd_newps(m,0,nf);                          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);
Line 1619  NODE nd_reduceall(int m,NODE f)
Line 1618  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 1628  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 1645  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 2001  void nd_gr(LIST f,LIST v,int m,struct order_spec *ord,
Line 2002  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 2018  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 2051  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 2060  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 2101  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 2541  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 2549  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.");
         }          }
 }  }
   
Legend:
Removed from v.1.48  
changed lines
  Added in v.1.52
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>