[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.35 and 1.38

version 1.35, 2004/05/14 06:02:54 version 1.38, 2004/12/06 09:29:34
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.34 2004/04/22 07:52:38 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/dp-supp.c,v 1.37 2004/09/15 06:06:42 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 62  extern int NoGCD;
Line 62  extern int NoGCD;
 extern int GenTrace;  extern int GenTrace;
 extern NODE TraceList;  extern NODE TraceList;
   
   int show_orderspec;
   
   void print_composite_order_spec(struct order_spec *spec);
   
 /*  /*
  * content reduction   * content reduction
  *   *
Line 1317  void dp_nf_tab_f(DP p,LIST *tab,DP *rp)
Line 1321  void dp_nf_tab_f(DP p,LIST *tab,DP *rp)
   
 int create_order_spec(VL vl,Obj obj,struct order_spec **specp)  int create_order_spec(VL vl,Obj obj,struct order_spec **specp)
 {  {
         int i,j,n,s,row,col;          int i,j,n,s,row,col,ret;
         struct order_spec *spec;          struct order_spec *spec;
         struct order_pair *l;          struct order_pair *l;
         NODE node,t,tn;          NODE node,t,tn;
Line 1325  int create_order_spec(VL vl,Obj obj,struct order_spec 
Line 1329  int create_order_spec(VL vl,Obj obj,struct order_spec 
         pointer **b;          pointer **b;
         int **w;          int **w;
   
         if ( vl && obj && OID(obj) == O_LIST )          if ( vl && obj && OID(obj) == O_LIST ) {
                 return create_composite_order_spec(vl,(LIST)obj,specp);                  ret = create_composite_order_spec(vl,(LIST)obj,specp);
                   if ( show_orderspec )
                           print_composite_order_spec(*specp);
                   return ret;
           }
   
         *specp = spec = (struct order_spec *)MALLOC(sizeof(struct order_spec));          *specp = spec = (struct order_spec *)MALLOC(sizeof(struct order_spec));
         if ( !obj || NUM(obj) ) {          if ( !obj || NUM(obj) ) {
Line 1406  void print_composite_order_spec(struct order_spec *spe
Line 1414  void print_composite_order_spec(struct order_spec *spe
         }          }
 }  }
   
   struct order_spec *append_block(struct order_spec *spec,
           int nv,int nalg,int ord)
   {
           MAT m,mat;
           int i,j,row,col,n;
           Q **b,**wp;
           int **w;
           NODE t,s,s0;
           struct order_pair *l,*l0;
           int n0,nv0;
           LIST list0,list1,list;
           Q oq,nq;
           struct order_spec *r;
   
           r = (struct order_spec *)MALLOC(sizeof(struct order_spec));
           switch ( spec->id ) {
                   case 0:
                           STOQ(spec->ord.simple,oq); STOQ(nv,nq);
                           t = mknode(2,oq,nq); MKLIST(list0,t);
                           STOQ(ord,oq); STOQ(nalg,nq);
                           t = mknode(2,oq,nq); MKLIST(list1,t);
                           t = mknode(2,list0,list1); MKLIST(list,t);
                           l = (struct order_pair *)MALLOC_ATOMIC(2*sizeof(struct order_pair));
                           l[0].order = spec->ord.simple; l[0].length = nv;
                           l[1].order = ord; l[1].length = nalg;
                           r->id = 1;  r->obj = (Obj)list;
                           r->ord.block.order_pair = l;
                           r->ord.block.length = 2;
                           r->nv = nv+nalg;
                           break;
                   case 1:
                           if ( spec->nv != nv )
                                   error("append_block : number of variables mismatch");
                           l0 = spec->ord.block.order_pair;
                           n0 = spec->ord.block.length;
                           nv0 = spec->nv;
                           list0 = (LIST)spec->obj;
                           n = n0+1;
                           l = (struct order_pair *)MALLOC_ATOMIC(n*sizeof(struct order_pair));
                           for ( i = 0; i < n0; i++ )
                                   l[i] = l0[i];
                           l[i].order = ord; l[i].length = nalg;
                            for ( t = BDY(list0), s0 = 0; t; t = NEXT(t) ) {
                                   NEXTNODE(s0,s); BDY(s) = BDY(t);
                           }
                           STOQ(ord,oq); STOQ(nalg,nq);
                           t = mknode(2,oq,nq); MKLIST(list,t);
                           NEXTNODE(s0,s); BDY(s) = (pointer)list; NEXT(s) = 0;
                           MKLIST(list,s0);
                           r->id = 1;  r->obj = (Obj)list;
                           r->ord.block.order_pair = l;
                           r->ord.block.length = n;
                           r->nv = nv+nalg;
                           break;
                   case 2:
                           if ( spec->nv != nv )
                                   error("append_block : number of variables mismatch");
                           m = (MAT)spec->obj;
                           row = m->row; col = m->col; b = (Q **)BDY(m);
                           w = almat(row+nalg,col+nalg);
                           MKMAT(mat,row+nalg,col+nalg); wp = (Q **)BDY(mat);
                           for ( i = 0; i < row; i++ )
                                   for ( j = 0; j < col; j++ ) {
                                           w[i][j] = QTOS(b[i][j]);
                                           wp[i][j] = b[i][j];
                                   }
                           for ( i = 0; i < nalg; i++ ) {
                                   w[i+row][i+col] = 1;
                                   wp[i+row][i+col] = ONE;
                           }
                           r->id = 2; r->obj = (Obj)mat;
                           r->nv = col+nalg; r->ord.matrix.row = row+nalg;
                           r->ord.matrix.matrix = w;
                           break;
                   case 3:
                   default:
                           /* XXX */
                           error("append_block : not implemented yet");
           }
           return r;
   }
   
   int comp_sw(struct sparse_weight *a, struct sparse_weight *b)
   {
           if ( a->pos > b->pos ) return 1;
           else if ( a->pos < b->pos ) return -1;
           else return 0;
   }
   
 /* order = [w_or_b, w_or_b, ... ] */  /* order = [w_or_b, w_or_b, ... ] */
 /* w_or_b = w or b                */  /* w_or_b = w or b                */
 /* w = [1,2,...] or [x,1,y,2,...] */  /* w = [1,2,...] or [x,1,y,2,...] */
Line 1483  int create_composite_order_spec(VL vl,LIST order,struc
Line 1580  int create_composite_order_spec(VL vl,LIST order,struc
                                         error("a sparse weight vector must be specified as [var1,weight1,...]");                                          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);
                         }                          }
                           qsort(sw,len,sizeof(struct sparse_weight),
                                   (int (*)(const void *,const void *))comp_sw);
                         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;
Line 1565  int create_composite_order_spec(VL vl,LIST order,struc
Line 1664  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 */  /* module order spec */
Legend:
Removed from v.1.35  
changed lines
  Added in v.1.38
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>