[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.31 and 1.36

version 1.31, 2004/03/09 09:40:46 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.30 2004/03/05 02:26:52 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 1565  int create_composite_order_spec(VL vl,LIST order,struc
Line 1565  int create_composite_order_spec(VL vl,LIST order,struc
                 w_or_b[n].body.block.order = 0;                  w_or_b[n].body.block.order = 0;
                 spec->ord.composite.length = n+1;                  spec->ord.composite.length = n+1;
         }          }
         if ( 1 ) print_composite_order_spec(spec);  
 }  }
   
   /* 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 1867  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 1989  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.31  
changed lines
  Added in v.1.36

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>