[BACK]Return to dp-supp.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/dp-supp.c between version 1.28 and 1.36

version 1.28, 2004/02/05 08:28:53 version 1.36, 2004/05/14 09:20:56
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp-supp.c,v 1.27 2004/02/03 23:31:57 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp-supp.c,v 1.35 2004/05/14 06:02:54 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 1311  void dp_nf_tab_f(DP p,LIST *tab,DP *rp)
Line 1311  void dp_nf_tab_f(DP p,LIST *tab,DP *rp)
   
 /*  /*
  * setting flags   * setting flags
    * call create_order_spec with vl=0 to set old type order.
  *   *
  */   */
   
Line 1415  int create_composite_order_spec(VL vl,LIST order,struc
Line 1416  int create_composite_order_spec(VL vl,LIST order,struc
         NODE wb,t,p;          NODE wb,t,p;
         struct order_spec *spec;          struct order_spec *spec;
         VL tvl;          VL tvl;
         int n,i,j,k,l,len;          int n,i,j,k,l,start,end,len,w;
         int *dw;          int *dw;
         struct sparse_weight *sw;          struct sparse_weight *sw;
         struct weight_or_block *w_or_b;          struct weight_or_block *w_or_b;
         Obj a0;          Obj a0;
         NODE a;          NODE a;
         V v;          V v,sv,ev;
         Symbol sym;          SYMBOL sym;
         int start;          int *top;
   
         /* l = number of vars in vl */          /* l = number of vars in vl */
         for ( l = 0, tvl = vl; tvl; tvl = NEXT(tvl), l++ );          for ( l = 0, tvl = vl; tvl; tvl = NEXT(tvl), l++ );
Line 1436  int create_composite_order_spec(VL vl,LIST order,struc
Line 1437  int create_composite_order_spec(VL vl,LIST order,struc
         spec->nv = l;          spec->nv = l;
         spec->ord.composite.length = n;          spec->ord.composite.length = n;
         w_or_b = spec->ord.composite.w_or_b = (struct weight_or_block *)          w_or_b = spec->ord.composite.w_or_b = (struct weight_or_block *)
                 MALLOC(sizeof(struct weight_or_block)*n);                  MALLOC(sizeof(struct weight_or_block)*(n+1));
   
           /* top : register the top variable in each w_or_b specification */
           top = (int *)ALLOCA(l*sizeof(int));
           for ( i = 0; i < l; i++ ) top[i] = 0;
   
         for ( t = wb, i = 0; t; t = NEXT(t), i++ ) {          for ( t = wb, i = 0; t; t = NEXT(t), i++ ) {
                   if ( !BDY(t) || OID((Obj)BDY(t)) != O_LIST )
                           error("a list of lists must be specified for the key \"order\"");
                 a = BDY((LIST)BDY(t));                  a = BDY((LIST)BDY(t));
                 len = length(a);                  len = length(a);
                 a0 = (Obj)BDY(a);                  a0 = (Obj)BDY(a);
                 if ( !a0 || OID(a0) == O_N ) {                  if ( !a0 || OID(a0) == O_N ) {
                         /* a is a dense weight vector */                          /* a is a dense weight vector */
                         dw = (int *)MALLOC(sizeof(int)*len);                          dw = (int *)MALLOC(sizeof(int)*len);
                         for ( j = 0, p = a; j < len; p = NEXT(p), j++ )                          for ( j = 0, p = a; j < len; p = NEXT(p), j++ ) {
                                   if ( !INT((Q)BDY(p)) )
                                           error("a dense weight vector must be specified as a list of integers");
                                 dw[j] = QTOS((Q)BDY(p));                                  dw[j] = QTOS((Q)BDY(p));
                           }
                         w_or_b[i].type = IS_DENSE_WEIGHT;                          w_or_b[i].type = IS_DENSE_WEIGHT;
                         w_or_b[i].length = len;                          w_or_b[i].length = len;
                         w_or_b[i].body.dense_weight = dw;                          w_or_b[i].body.dense_weight = dw;
   
                           /* find the top */
                           for ( k = 0; k < len && !dw[k]; k++ );
                           if ( k < len ) top[k] = 1;
   
                 } else if ( OID(a0) == O_P ) {                  } else if ( OID(a0) == O_P ) {
                         /* a is a sparse weight vector */                          /* a is a sparse weight vector */
                         len >>= 1;                          len >>= 1;
                         sw = (struct sparse_weight *)                          sw = (struct sparse_weight *)
                                 MALLOC(sizeof(struct sparse_weight)*len);                                  MALLOC(sizeof(struct sparse_weight)*len);
                         for ( j = 0, p = a; j < len; j++ ) {                          for ( j = 0, p = a; j < len; j++ ) {
                                   if ( !BDY(p) || OID((P)BDY(p)) != O_P )
                                           error("a sparse weight vector must be specified as [var1,weight1,...]");
                                 v = VR((P)BDY(p)); p = NEXT(p);                                  v = VR((P)BDY(p)); p = NEXT(p);
                                 for ( tvl = vl, k = 0; tvl && tvl->v != v;                                  for ( tvl = vl, k = 0; tvl && tvl->v != v;
                                         k++, tvl = NEXT(tvl) );                                          k++, tvl = NEXT(tvl) );
                                 if ( !tvl )                                  if ( !tvl )
                                         error("invalid variable name");                                          error("invalid variable name in a sparse weight vector");
                                 sw[j].pos = k;                                  sw[j].pos = k;
                                   if ( !INT((Q)BDY(p)) )
                                           error("a sparse weight vector must be specified as [var1,weight1,...]");
                                 sw[j].value = QTOS((Q)BDY(p)); p = NEXT(p);                                  sw[j].value = QTOS((Q)BDY(p)); p = NEXT(p);
                         }                          }
                         w_or_b[i].type = IS_SPARSE_WEIGHT;                          w_or_b[i].type = IS_SPARSE_WEIGHT;
                         w_or_b[i].length = len;                          w_or_b[i].length = len;
                         w_or_b[i].body.sparse_weight = sw;                          w_or_b[i].body.sparse_weight = sw;
   
                           /* find the top */
                           for ( k = 0; k < len && !sw[k].value; k++ );
                           if ( k < len ) top[sw[k].pos] = 1;
                   } else if ( OID(a0) == O_RANGE ) {
                           /* [range(v1,v2),w] */
                           sv = VR((P)(((RANGE)a0)->start));
                           ev = VR((P)(((RANGE)a0)->end));
                           for ( tvl = vl, start = 0; tvl && tvl->v != sv; start++, tvl = NEXT(tvl) );
                           if ( !tvl )
                                   error("invalid range");
                           for ( end = start; tvl && tvl->v != ev; end++, tvl = NEXT(tvl) );
                           if ( !tvl )
                                   error("invalid range");
                           len = end-start+1;
                           sw = (struct sparse_weight *)
                                   MALLOC(sizeof(struct sparse_weight)*len);
                           w = QTOS((Q)BDY(NEXT(a)));
                           for ( tvl = vl, k = 0; k < start; k++, tvl = NEXT(tvl) );
                           for ( j = 0 ; k <= end; k++, tvl = NEXT(tvl), j++ ) {
                                   sw[j].pos = k;
                                   sw[j].value = w;
                           }
                           w_or_b[i].type = IS_SPARSE_WEIGHT;
                           w_or_b[i].length = len;
                           w_or_b[i].body.sparse_weight = sw;
   
                           /* register the top */
                           if ( w ) top[start] = 1;
                 } else if ( OID(a0) == O_SYMBOL ) {                  } else if ( OID(a0) == O_SYMBOL ) {
                         /* a is a block */                          /* a is a block */
                         sym = (Symbol)a0; a = NEXT(a); len--;                          sym = (SYMBOL)a0; a = NEXT(a); len--;
                         for ( start = 0, tvl = vl; tvl->v != VR((P)BDY(a));                          if ( OID((Obj)BDY(a)) == O_RANGE ) {
                                   sv = VR((P)(((RANGE)BDY(a))->start));
                                   ev = VR((P)(((RANGE)BDY(a))->end));
                                   for ( tvl = vl, start = 0; tvl && tvl->v != sv; start++, tvl = NEXT(tvl) );
                                   if ( !tvl )
                                           error("invalid range");
                                   for ( end = start; tvl && tvl->v != ev; end++, tvl = NEXT(tvl) );
                                   if ( !tvl )
                                           error("invalid range");
                                   len = end-start+1;
                           } else {
                                   for ( start = 0, tvl = vl; tvl->v != VR((P)BDY(a));
                                 tvl = NEXT(tvl), start++ );                                  tvl = NEXT(tvl), start++ );
                         for ( p = NEXT(a), tvl = NEXT(tvl); p;                                  for ( p = NEXT(a), tvl = NEXT(tvl); p;
                                 p = NEXT(p), tvl = NEXT(tvl) )                                          p = NEXT(p), tvl = NEXT(tvl) ) {
                                 if ( tvl->v != VR((P)BDY(p)) ) break;                                          if ( !BDY(p) || OID((P)BDY(p)) != O_P )
                         if ( p )                                                  error("a block must be specified as [ordsymbol,var1,var2,...]");
                                 error("a block must be contiguous");                                          if ( tvl->v != VR((P)BDY(p)) ) break;
                                   }
                                   if ( p )
                                           error("a block must be contiguous in the variable list");
                           }
                         w_or_b[i].type = IS_BLOCK;                          w_or_b[i].type = IS_BLOCK;
                         w_or_b[i].length = len;                          w_or_b[i].length = len;
                         w_or_b[i].body.block.start = start;                          w_or_b[i].body.block.start = start;
Line 1486  int create_composite_order_spec(VL vl,LIST order,struc
Line 1550  int create_composite_order_spec(VL vl,LIST order,struc
                         else if ( !strcmp(sym->name,"@lex") )                          else if ( !strcmp(sym->name,"@lex") )
                                 w_or_b[i].body.block.order = 2;                                  w_or_b[i].body.block.order = 2;
                         else                          else
                                 error("invalid ordernam");                                  error("invalid ordername");
                           /* register the tops */
                           for ( j = 0, k = start; j < len; j++, k++ )
                                   top[k] = 1;
                 }                  }
         }          }
         if ( 1 ) print_composite_order_spec(spec);          for ( k = 0; k < l && top[k]; k++ );
           if ( k < l ) {
                   /* incomplete order specification; add @grlex */
                   w_or_b[n].type = IS_BLOCK;
                   w_or_b[n].length = l;
                   w_or_b[n].body.block.start = 0;
                   w_or_b[n].body.block.order = 0;
                   spec->ord.composite.length = n+1;
           }
 }  }
   
   /* module order spec */
   
   void create_modorder_spec(int id,LIST shift,struct modorder_spec **s)
   {
           struct modorder_spec *spec;
           NODE n,t;
           LIST list;
           int *ds;
           int i,l;
           Q q;
   
           *s = spec = (struct modorder_spec *)MALLOC(sizeof(struct modorder_spec));
           spec->id = id;
           if ( shift ) {
                   n = BDY(shift);
                   spec->len = l = length(n);
                   spec->degree_shift = ds = (int *)MALLOC_ATOMIC(l*sizeof(int));
                   for ( t = n, i = 0; t; t = NEXT(t), i++ )
                           ds[i] = QTOS((Q)BDY(t));
           } else {
                   spec->len = 0;
                   spec->degree_shift = 0;
           }
           STOQ(id,q);
           n = mknode(2,q,shift);
           MKLIST(list,n);
           spec->obj = (Obj)list;
   }
   
 /*  /*
  * converters   * converters
  *   *
Line 1595  void homogenize_order(struct order_spec *old,int n,str
Line 1699  void homogenize_order(struct order_spec *old,int n,str
         int length,nv,row,i,j;          int length,nv,row,i,j;
         int **newm,**oldm;          int **newm,**oldm;
         struct order_spec *new;          struct order_spec *new;
           int onv,nnv,nlen,olen,owlen;
           struct weight_or_block *owb,*nwb;
   
         *newp = new = (struct order_spec *)MALLOC(sizeof(struct order_spec));          *newp = new = (struct order_spec *)MALLOC(sizeof(struct order_spec));
         switch ( old->id ) {          switch ( old->id ) {
Line 1645  void homogenize_order(struct order_spec *old,int n,str
Line 1751  void homogenize_order(struct order_spec *old,int n,str
                         new->id = 2; new->nv = nv+1;                          new->id = 2; new->nv = nv+1;
                         new->ord.matrix.row = row+1; new->ord.matrix.matrix = newm;                          new->ord.matrix.row = row+1; new->ord.matrix.matrix = newm;
                         break;                          break;
                   case 3:
                           onv = old->nv;
                           nnv = onv+1;
                           olen = old->ord.composite.length;
                           nlen = olen+1;
                           owb = old->ord.composite.w_or_b;
                           nwb = (struct weight_or_block *)
                                   MALLOC(nlen*sizeof(struct weight_or_block));
                           for ( i = 0; i < olen; i++ ) {
                                   nwb[i].type = owb[i].type;
                                   switch ( owb[i].type ) {
                                           case IS_DENSE_WEIGHT:
                                                   owlen = owb[i].length;
                                                   nwb[i].length = owlen+1;
                                                   nwb[i].body.dense_weight = (int *)MALLOC((owlen+1)*sizeof(int));
                                                   for ( j = 0; j < owlen; j++ )
                                                           nwb[i].body.dense_weight[j] = owb[i].body.dense_weight[j];
                                                   nwb[i].body.dense_weight[owlen] = 0;
                                                   break;
                                           case IS_SPARSE_WEIGHT:
                                                   nwb[i].length = owb[i].length;
                                                   nwb[i].body.sparse_weight = owb[i].body.sparse_weight;
                                                   break;
                                           case IS_BLOCK:
                                                   nwb[i].length = owb[i].length;
                                                   nwb[i].body.block = owb[i].body.block;
                                                   break;
                                   }
                           }
                           nwb[i].type = IS_SPARSE_WEIGHT;
                           nwb[i].body.sparse_weight =
                                   (struct sparse_weight *)MALLOC(sizeof(struct sparse_weight));
                           nwb[i].body.sparse_weight[0].pos = onv;
                           nwb[i].body.sparse_weight[0].value = 1;
                           new->id = 3;
                           new->nv = nnv;
                           new->ord.composite.length = nlen;
                           new->ord.composite.w_or_b = nwb;
                           print_composite_order_spec(new);
                           break;
                 default:                  default:
                         error("homogenize_order : invalid input");                          error("homogenize_order : invalid input");
         }          }
Line 1749  void dp_hm(DP p,DP *rp)
Line 1895  void dp_hm(DP p,DP *rp)
         }          }
 }  }
   
   void dp_ht(DP p,DP *rp)
   {
           MP m,mr;
   
           if ( !p )
                   *rp = 0;
           else {
                   m = BDY(p);
                   NEWMP(mr); mr->dl = m->dl; mr->c = (P)ONE; NEXT(mr) = 0;
                   MKDP(p->nv,mr,*rp); (*rp)->sugar = mr->dl->td;  /* XXX */
           }
   }
   
 void dp_rest(DP p,DP *rp)  void dp_rest(DP p,DP *rp)
 {  {
         MP m;          MP m;
Line 1871  void dp_sort(DP p,DP *rp)
Line 2030  void dp_sort(DP p,DP *rp)
         *rp = r;          *rp = r;
 }  }
   
   DP extract_initial_term_from_dp(DP p,int *weight,int n);
   LIST extract_initial_term(LIST f,int *weight,int n);
   
   DP extract_initial_term_from_dp(DP p,int *weight,int n)
   {
           int w,t,i,top;
           MP m,r0,r;
           DP dp;
   
           if ( !p ) return 0;
           top = 1;
           for ( m = BDY(p); m; m = NEXT(m) ) {
                   for ( i = 0, t = 0; i < n; i++ )
                           t += weight[i]*m->dl->d[i];
                   if ( top || t > w ) {
                           r0 = 0;
                           w = t;
                           top = 0;
                   }
                   if ( t == w ) {
                           NEXTMP(r0,r);
                           r->dl = m->dl;
                           r->c = m->c;
                   }
           }
           NEXT(r) = 0;
           MKDP(p->nv,r0,dp);
           return dp;
   }
   
   LIST extract_initial_term(LIST f,int *weight,int n)
   {
           NODE nd,r0,r;
           Obj p;
           LIST l;
   
           nd = BDY(f);
           for ( r0 = 0; nd; nd = NEXT(nd) ) {
                   NEXTNODE(r0,r);
                   p = (Obj)BDY(nd);
                   BDY(r) = (pointer)extract_initial_term_from_dp((DP)p,weight,n);
           }
           if ( r0 ) NEXT(r) = 0;
           MKLIST(l,r0);
           return l;
   }
   
   LIST dp_initial_term(LIST f,struct order_spec *ord)
   {
           int n,l,i;
           struct weight_or_block *worb;
           int *weight;
   
           switch ( ord->id ) {
                   case 2: /* matrix order */
                           /* extract the first row */
                           n = ord->nv;
                           weight = ord->ord.matrix.matrix[0];
                           return extract_initial_term(f,weight,n);
                   case 3: /* composite order */
                           /* the first w_or_b */
                           worb = ord->ord.composite.w_or_b;
                           switch ( worb->type ) {
                                   case IS_DENSE_WEIGHT:
                                           n = worb->length;
                                           weight = worb->body.dense_weight;
                                           return extract_initial_term(f,weight,n);
                                   case IS_SPARSE_WEIGHT:
                                           n = ord->nv;
                                           weight = (int *)ALLOCA(n*sizeof(int));
                                           for ( i = 0; i < n; i++ ) weight[i] = 0;
                                           l = worb->length;
                                           for ( i = 0; i < l; i++ )
                                                   weight[worb->body.sparse_weight[i].pos]
                                                           =  worb->body.sparse_weight[i].value;
                                           return extract_initial_term(f,weight,n);
                                   default:
                                           error("dp_initial_term : unsupported order");
                           }
                   default:
                           error("dp_initial_term : unsupported order");
           }
   }
   
   int highest_order_dp(DP p,int *weight,int n);
   LIST highest_order(LIST f,int *weight,int n);
   
   int highest_order_dp(DP p,int *weight,int n)
   {
           int w,t,i,top;
           MP m;
   
           if ( !p ) return -1;
           top = 1;
           for ( m = BDY(p); m; m = NEXT(m) ) {
                   for ( i = 0, t = 0; i < n; i++ )
                           t += weight[i]*m->dl->d[i];
                   if ( top || t > w ) {
                           w = t;
                           top = 0;
                   }
           }
           return w;
   }
   
   LIST highest_order(LIST f,int *weight,int n)
   {
           int h;
           NODE nd,r0,r;
           Obj p;
           LIST l;
           Q q;
   
           nd = BDY(f);
           for ( r0 = 0; nd; nd = NEXT(nd) ) {
                   NEXTNODE(r0,r);
                   p = (Obj)BDY(nd);
                   h = highest_order_dp((DP)p,weight,n);
                   STOQ(h,q);
                   BDY(r) = (pointer)q;
           }
           if ( r0 ) NEXT(r) = 0;
           MKLIST(l,r0);
           return l;
   }
   
   LIST dp_order(LIST f,struct order_spec *ord)
   {
           int n,l,i;
           struct weight_or_block *worb;
           int *weight;
   
           switch ( ord->id ) {
                   case 2: /* matrix order */
                           /* extract the first row */
                           n = ord->nv;
                           weight = ord->ord.matrix.matrix[0];
                           return highest_order(f,weight,n);
                   case 3: /* composite order */
                           /* the first w_or_b */
                           worb = ord->ord.composite.w_or_b;
                           switch ( worb->type ) {
                                   case IS_DENSE_WEIGHT:
                                           n = worb->length;
                                           weight = worb->body.dense_weight;
                                           return highest_order(f,weight,n);
                                   case IS_SPARSE_WEIGHT:
                                           n = ord->nv;
                                           weight = (int *)ALLOCA(n*sizeof(int));
                                           for ( i = 0; i < n; i++ ) weight[i] = 0;
                                           l = worb->length;
                                           for ( i = 0; i < l; i++ )
                                                   weight[worb->body.sparse_weight[i].pos]
                                                           =  worb->body.sparse_weight[i].value;
                                           return highest_order(f,weight,n);
                                   default:
                                           error("dp_initial_term : unsupported order");
                           }
                   default:
                           error("dp_initial_term : unsupported order");
           }
   }
   
   int dpv_ht(DPV p,DP *h)
   {
           int len,max,maxi,i,t;
           DP *e;
           MP m,mr;
   
           len = p->len;
           e = p->body;
           max = -1;
           maxi = -1;
           for ( i = 0; i < len; i++ )
                   if ( e[i] && (t = BDY(e[i])->dl->td) > max ) {
                           max = t;
                           maxi = i;
                   }
           if ( max < 0 ) {
                   *h = 0;
                   return -1;
           } else {
                   m = BDY(e[maxi]);
                   NEWMP(mr); mr->dl = m->dl; mr->c = (P)ONE; NEXT(mr) = 0;
                   MKDP(e[maxi]->nv,mr,*h); (*h)->sugar = mr->dl->td;  /* XXX */
                   return maxi;
           }
   }
Legend:
Removed from v.1.28  
changed lines
  Added in v.1.36
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>