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

Diff for /OpenXM_contrib2/asir2000/builtin/gr.c between version 1.6 and 1.13

version 1.6, 2000/07/13 05:09:00 version 1.13, 2000/12/05 08:29:43
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.5 2000/05/29 08:54:45 noro Exp $ */  /*
    * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    *
    * $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.12 2000/12/05 06:59:15 noro Exp $
   */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "base.h"  #include "base.h"
Line 35  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
Line 83  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
 extern int (*cmpdl)();  extern int (*cmpdl)();
 extern int do_weyl;  extern int do_weyl;
   
 void Pdp_gr_flags(), Pdp_gr_print();  extern DP_Print;
 void Pdp_gr_main(),Pdp_gr_mod_main(),Pdp_f4_main(),Pdp_f4_mod_main();  
   
 void print_stat(void);  void print_stat(void);
 void init_stat(void);  void init_stat(void);
 int dp_load_t(int,DP *);  int dp_load_t(int,DP *);
 void dp_load(int,DP *);  void dp_load(int,DP *);
 void dp_save(int,DP);  void dp_save(int,Obj,char *);
 void dp_make_flaglist(LIST *);  void dp_make_flaglist(LIST *);
 void dp_set_flag(Obj,Obj);  void dp_set_flag(Obj,Obj);
 int membercheck(NODE,NODE);  int membercheck(NODE,NODE);
Line 60  DP_pairs updpairs(DP_pairs,NODE,int);
Line 107  DP_pairs updpairs(DP_pairs,NODE,int);
 void _dp_nf_ptozp(NODE,DP,DP *,int,int,DP *);  void _dp_nf_ptozp(NODE,DP,DP *,int,int,DP *);
 void _dp_nf_ptozp_mpi(NODE,DP,DP *,int,int,DP *);  void _dp_nf_ptozp_mpi(NODE,DP,DP *,int,int,DP *);
 void _dp_nf(NODE,DP,DP *,int,DP *);  void _dp_nf(NODE,DP,DP *,int,DP *);
 void _dp_nf_mod(NODE,DP,DP *,int,int,DP *);  
 void interreduce_mod(NODE,int,int);  
 NODE gb_mod(NODE,int);  NODE gb_mod(NODE,int);
 NODE gbd(NODE,int,NODE,NODE);  NODE gbd(NODE,int,NODE,NODE);
 NODE gb(NODE,int,NODE);  NODE gb(NODE,int,NODE);
Line 96  void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,
Line 141  void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,
 double get_rtime();  double get_rtime();
 void _dpmod_to_vect(DP,DL *,int *);  void _dpmod_to_vect(DP,DL *,int *);
 void dp_to_vect(DP,DL *,Q *);  void dp_to_vect(DP,DL *,Q *);
 NODE dp_dllist(DP f),symb_merge(NODE,NODE,int);  NODE dp_dllist(DP f);
   NODE symb_merge(NODE,NODE,int),_symb_merge(NODE,NODE,int);
 extern int dp_nelim;  extern int dp_nelim;
 extern int dp_fcoeffs;  extern int dp_fcoeffs;
 static DP *ps,*psm;  static DP *ps,*psm;
Line 113  static int NoCriB = 0;
Line 158  static int NoCriB = 0;
 static int NoGC = 0;  static int NoGC = 0;
 static int NoMC = 0;  static int NoMC = 0;
 static int NoRA = 0;  static int NoRA = 0;
 int Print = 0;  int DP_Print = 0;
 static int PrintShort = 0;  static int DP_PrintShort = 0;
 static int ShowMag = 0;  static int ShowMag = 0;
 static int Stat = 0;  static int Stat = 0;
 static int Multiple = 0;  static int Multiple = 0;
 static int Denominator = 1;  static int Denominator = 1;
 static int Top = 0;  static int Top = 0;
 static int Reverse = 0;  static int Reverse = 0;
 static int InterReduce = 0;  
 static int Max_mag = 0;  static int Max_mag = 0;
 static char *Demand = 0;  static char *Demand = 0;
 static int PtozpRA = 0;  static int PtozpRA = 0;
 LIST Dist = 0;  LIST Dist = 0;
 int NoGCD = 0;  int NoGCD = 0;
   int GenTrace = 0;
   int OXCheck = -1;
 int doing_f4;  int doing_f4;
   NODE TraceList;
   
 void Pdp_gr_flags(arg,rp)  
 NODE arg;  
 LIST *rp;  
 {  
         Obj name,value;  
         NODE n;  
   
         if ( arg ) {  
                 asir_assert(ARG0(arg),O_LIST,"dp_gr_flags");  
                 n = BDY((LIST)ARG0(arg));  
                 while ( n ) {  
                         name = (Obj)BDY(n); n = NEXT(n);  
                         if ( !n )  
                                 break;  
                         else {  
                                 value = (Obj)BDY(n); n = NEXT(n);  
                         }  
                         dp_set_flag(name,value);  
                 }  
         }  
         dp_make_flaglist(rp);  
 }  
   
 void Pdp_gr_print(arg,rp)  
 NODE arg;  
 Q *rp;  
 {  
         Q q;  
   
         if ( arg ) {  
                 asir_assert(ARG0(arg),O_N,"dp_gr_print");  
                 q = (Q)ARG0(arg); Print = QTOS(q);  
         } else  
                 STOQ(Print,q);  
         *rp = q;  
 }  
   
 void Pdp_gr_main(arg,rp)  
 NODE arg;  
 LIST *rp;  
 {  
         LIST f,v;  
         Num homo;  
         Q m;  
         int modular;  
         struct order_spec ord;  
   
         asir_assert(ARG0(arg),O_LIST,"dp_gr_main");  
         asir_assert(ARG1(arg),O_LIST,"dp_gr_main");  
         asir_assert(ARG2(arg),O_N,"dp_gr_main");  
         asir_assert(ARG3(arg),O_N,"dp_gr_main");  
         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);  
         homo = (Num)ARG2(arg);  
         m = (Q)ARG3(arg);  
         if ( !m )  
                 modular = 0;  
         else if ( PL(NM(m))>1 || (PL(NM(m)) == 1 && BD(NM(m))[0] >= 0x80000000) )  
                 error("dp_gr_main : too large modulus");  
         else  
                 modular = QTOS(m);  
         create_order_spec(ARG4(arg),&ord);  
         dp_gr_main(f,v,homo,modular,&ord,rp);  
 }  
   
 void Pdp_f4_main(arg,rp)  
 NODE arg;  
 LIST *rp;  
 {  
         LIST f,v;  
         struct order_spec ord;  
   
         asir_assert(ARG0(arg),O_LIST,"dp_f4_main");  
         asir_assert(ARG1(arg),O_LIST,"dp_f4_main");  
         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);  
         create_order_spec(ARG2(arg),&ord);  
         dp_f4_main(f,v,&ord,rp);  
 }  
   
 void Pdp_f4_mod_main(arg,rp)  
 NODE arg;  
 LIST *rp;  
 {  
         LIST f,v;  
         int m;  
         struct order_spec ord;  
   
         asir_assert(ARG0(arg),O_LIST,"dp_f4_main");  
         asir_assert(ARG1(arg),O_LIST,"dp_f4_main");  
         asir_assert(ARG2(arg),O_N,"dp_f4_main");  
         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); m = QTOS((Q)ARG2(arg));  
         create_order_spec(ARG3(arg),&ord);  
         dp_f4_mod_main(f,v,m,&ord,rp);  
 }  
   
 void Pdp_gr_mod_main(arg,rp)  
 NODE arg;  
 LIST *rp;  
 {  
         LIST f,v;  
         Num homo;  
         int m;  
         struct order_spec ord;  
   
         asir_assert(ARG0(arg),O_LIST,"dp_gr_mod_main");  
         asir_assert(ARG1(arg),O_LIST,"dp_gr_mod_main");  
         asir_assert(ARG2(arg),O_N,"dp_gr_mod_main");  
         asir_assert(ARG3(arg),O_N,"dp_gr_mod_main");  
         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);  
         homo = (Num)ARG2(arg); m = QTOS((Q)ARG3(arg));  
         create_order_spec(ARG4(arg),&ord);  
         dp_gr_mod_main(f,v,homo,m,&ord,rp);  
 }  
   
 int eqdl(nv,dl1,dl2)  int eqdl(nv,dl1,dl2)
 int nv;  int nv;
 DL dl1,dl2;  DL dl1,dl2;
Line 367  LIST *rp;
Line 301  LIST *rp;
                 if ( homo ) {                  if ( homo ) {
                         initd(&ord1); CNVars = NVars+1;                          initd(&ord1); CNVars = NVars+1;
                 }                  }
                 if ( Print && modular ) {                  if ( DP_Print && modular ) {
                         fprintf(asir_out,"mod= %d, eval = ",m); printsubst(subst);                          fprintf(asir_out,"mod= %d, eval = ",m); printsubst(subst);
                 }                  }
                 x = gb(s,m,subst);                  x = gb(s,m,subst);
Line 576  NODE f;
Line 510  NODE f;
         while ( d ) {          while ( d ) {
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 minsugar(d,&dm,&dr); d = dr;                  minsugar(d,&dm,&dr); d = dr;
                 if ( Print )                  if ( DP_Print )
                         fprintf(asir_out,"sugar=%d\n",dm->sugar);                          fprintf(asir_out,"sugar=%d\n",dm->sugar);
                 blist = 0; s0 = 0;                  blist = 0; s0 = 0;
                 /* asph : sum of all head terms of spoly */                  /* asph : sum of all head terms of spoly */
Line 617  NODE f;
Line 551  NODE f;
                         dp_to_vect(BDY(r),at,(Q *)mat->body[i]);                          dp_to_vect(BDY(r),at,(Q *)mat->body[i]);
                 get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);
                 init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);                  init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);
                 if ( Print ) {                  if ( DP_Print ) {
                         print_eg("Symb",&eg_split_symb);                          print_eg("Symb",&eg_split_symb);
                         fprintf(asir_out,"mat : %d x %d",row,col);                          fprintf(asir_out,"mat : %d x %d",row,col);
                         fflush(asir_out);                          fflush(asir_out);
Line 627  NODE f;
Line 561  NODE f;
 #else  #else
                 rank = generic_gauss_elim(mat,&nm,&dn,&rind,&cind);                  rank = generic_gauss_elim(mat,&nm,&dn,&rind,&cind);
 #endif  #endif
                 if ( Print )                  if ( DP_Print )
                         fprintf(asir_out,"done rank = %d\n",rank,row,col);                          fprintf(asir_out,"done rank = %d\n",rank,row,col);
                 for ( i = 0; i < rank; i++ ) {                  for ( i = 0; i < rank; i++ ) {
                         for ( k = 0; k < nred; k++ )                          for ( k = 0; k < nred; k++ )
Line 652  NODE f;
Line 586  NODE f;
                         }                          }
                 }                  }
         }          }
         if ( Print ) {          if ( DP_Print ) {
                 print_eg("Symb",&eg_symb);                  print_eg("Symb",&eg_symb);
                 print_eg("Mod",&eg_mod); print_eg("GaussElim",&eg_elim);                  print_eg("Mod",&eg_mod); print_eg("GaussElim",&eg_elim);
                 print_eg("ChRem",&eg_chrem); print_eg("IntToRat",&eg_intrat);                  print_eg("ChRem",&eg_chrem); print_eg("IntToRat",&eg_intrat);
Line 694  int m;
Line 628  int m;
         while ( d ) {          while ( d ) {
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 minsugar(d,&dm,&dr); d = dr;                  minsugar(d,&dm,&dr); d = dr;
                 if ( Print )                  if ( DP_Print )
                         fprintf(asir_out,"sugar=%d\n",dm->sugar);                          fprintf(asir_out,"sugar=%d\n",dm->sugar);
                 blist = 0; s0 = 0;                  blist = 0; s0 = 0;
                 /* asph : sum of all head terms of spoly */                  /* asph : sum of all head terms of spoly */
Line 714  int m;
Line 648  int m;
                                 dltod(BDY(s),nv,&tdp);                                  dltod(BDY(s),nv,&tdp);
                                 dp_subd(tdp,ps[(int)BDY(r)],&sd);                                  dp_subd(tdp,ps[(int)BDY(r)],&sd);
                                 _dp_mod(sd,m,0,&sdm);                                  _dp_mod(sd,m,0,&sdm);
                                 _mulmd(CO,m,sdm,ps[(int)BDY(r)],&f2);                                  mulmd_dup(m,sdm,ps[(int)BDY(r)],&f2);
                                 MKNODE(bt,f2,blist); blist = bt;                                  MKNODE(bt,f2,blist); blist = bt;
                                 s = symb_merge(s,dp_dllist(f2),nv);                                  s = symb_merge(s,dp_dllist(f2),nv);
                                 nred++;                                  nred++;
Line 789  int m;
Line 723  int m;
                         for ( j = 0; j < spcol; j++ )                          for ( j = 0; j < spcol; j++ )
                                 if ( spmat[i][j] )                                  if ( spmat[i][j] )
                                         nonzero++;                                          nonzero++;
                 if ( Print )                  if ( DP_Print )
                         fprintf(asir_out,"spmat : %d x %d (nonzero=%f%%)...",                          fprintf(asir_out,"spmat : %d x %d (nonzero=%f%%)...",
                                 nsp,spcol,((double)nonzero*100)/(nsp*spcol));                                  nsp,spcol,((double)nonzero*100)/(nsp*spcol));
                 rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat);                  rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat);
Line 797  int m;
Line 731  int m;
                 get_eg(&tmp1); add_eg(&eg_elim2,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_elim2,&tmp0,&tmp1);
                 init_eg(&eg_split_elim2); add_eg(&eg_split_elim2,&tmp0,&tmp1);                  init_eg(&eg_split_elim2); add_eg(&eg_split_elim2,&tmp0,&tmp1);
   
                 if ( Print ) {                  if ( DP_Print ) {
                         fprintf(asir_out,"done rank = %d\n",rank,row,col);                          fprintf(asir_out,"done rank = %d\n",rank,row,col);
                         print_eg("Symb",&eg_split_symb);                          print_eg("Symb",&eg_split_symb);
                         print_eg("Elim1",&eg_split_elim1);                          print_eg("Elim1",&eg_split_elim1);
Line 822  int m;
Line 756  int m;
                                 i++;                                  i++;
                         }                          }
         }          }
         if ( Print ) {          if ( DP_Print ) {
                 print_eg("Symb",&eg_symb);                  print_eg("Symb",&eg_symb);
                 print_eg("Elim1",&eg_elim1);                  print_eg("Elim1",&eg_elim1);
                 print_eg("Elim2",&eg_elim2);                  print_eg("Elim2",&eg_elim2);
Line 956  NODE f,*r;
Line 890  NODE f,*r;
 int m;  int m;
 {  {
         int i;          int i;
         NODE s,s0;          NODE s,s0,f0;
   
         f = NODE_sortb(f,1);          f0 = f = NODE_sortb(f,1);
         psn = length(f); pslen = 2*psn;          psn = length(f); pslen = 2*psn;
         ps = (DP *)MALLOC(pslen*sizeof(DP));          ps = (DP *)MALLOC(pslen*sizeof(DP));
         psh = (DL *)MALLOC(pslen*sizeof(DL));          psh = (DL *)MALLOC(pslen*sizeof(DL));
Line 967  int m;
Line 901  int m;
         for ( i = 0; i < psn; i++, f = NEXT(f) ) {          for ( i = 0; i < psn; i++, f = NEXT(f) ) {
                 prim_part((DP)BDY(f),m,&ps[i]);                  prim_part((DP)BDY(f),m,&ps[i]);
                 if ( Demand )                  if ( Demand )
                         dp_save(i,ps[i]);                          dp_save(i,(Obj)ps[i],0);
                 psh[i] = BDY(ps[i])->dl;                  psh[i] = BDY(ps[i])->dl;
                 pss[i] = ps[i]->sugar;                  pss[i] = ps[i]->sugar;
                 psc[i] = BDY(ps[i])->c;                  psc[i] = BDY(ps[i])->c;
         }          }
           if ( GenTrace && (OXCheck >= 0) ) {
                   Q q;
                   STRING fname;
                   LIST input;
                   NODE arg;
                   Obj dmy;
   
                   STOQ(OXCheck,q);
                   MKSTR(fname,"register_input");
                   MKLIST(input,f0);
                   arg = mknode(3,q,fname,input);
                   Pox_cmo_rpc(arg,&dmy);
           }
         for ( s0 = 0, i = 0; i < psn; i++ ) {          for ( s0 = 0, i = 0; i < psn; i++ ) {
                 NEXTNODE(s0,s); BDY(s) = (pointer)i;                  NEXTNODE(s0,s); BDY(s) = (pointer)i;
         }          }
Line 983  void prim_part(f,m,r)
Line 930  void prim_part(f,m,r)
 DP f,*r;  DP f,*r;
 int m;  int m;
 {  {
           P d,t;
   
         if ( m > 0 ) {          if ( m > 0 ) {
                 if ( PCoeffs )                  if ( PCoeffs )
                         dp_prim_mod(f,m,r);                          dp_prim_mod(f,m,r);
Line 995  int m;
Line 944  int m;
                         dp_prim(f,r);                          dp_prim(f,r);
                 else                  else
                         dp_ptozp(f,r);                          dp_ptozp(f,r);
                   if ( GenTrace && TraceList ) {
                           divsp(CO,BDY(f)->c,BDY(*r)->c,&d);
                           mulp(CO,(P)ARG3(BDY((LIST)BDY(TraceList))),d,&t);
                           ARG3(BDY((LIST)BDY(TraceList))) = t;
                   }
         }          }
 }  }
   
Line 1077  NODE *h;
Line 1031  NODE *h;
         if ( NoRA ) {          if ( NoRA ) {
                 *h = in; return;                  *h = in; return;
         }          }
         if ( Print || PrintShort ) {          if ( DP_Print || DP_PrintShort ) {
                 fprintf(asir_out,"reduceall\n"); fflush(asir_out);                  fprintf(asir_out,"reduceall\n"); fflush(asir_out);
         }          }
         r = NODE_sortbi(in,0);          r = NODE_sortbi(in,0);
Line 1092  NODE *h;
Line 1046  NODE *h;
                         }                          }
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 dp_load(w[i],&ps[w[i]]);                  dp_load(w[i],&ps[w[i]]);
                 _dp_nf(top,ps[w[i]],ps,1,&g);  
   
                   if ( GenTrace ) {
                           Q q;
                           NODE node;
                           LIST hist;
   
                           STOQ(w[i],q);
                           node = mknode(4,ONE,q,ONE,ONE);
                           MKLIST(hist,node);
                           MKNODE(TraceList,hist,0);
                   }
                 if ( !PtozpRA || !Multiple )                  if ( !PtozpRA || !Multiple )
                         _dp_nf(top,ps[w[i]],ps,1,&g);                          _dp_nf(top,ps[w[i]],ps,1,&g);
                 else                  else
Line 1104  NODE *h;
Line 1067  NODE *h;
 #endif  #endif
                 prim_part(g,0,&g1);                  prim_part(g,0,&g1);
                 get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);
                 if ( Print || PrintShort ) {                  if ( DP_Print || DP_PrintShort ) {
                         fprintf(asir_out,"."); fflush(asir_out);                          fprintf(asir_out,"."); fflush(asir_out);
                 }                  }
                 w[i] = newps(g1,0,(NODE)0);                  w[i] = newps(g1,0,(NODE)0);
Line 1113  NODE *h;
Line 1076  NODE *h;
                 MKNODE(t,(pointer)w[j],top); top = t;                  MKNODE(t,(pointer)w[j],top); top = t;
         }          }
         *h = top;          *h = top;
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"\n");                  fprintf(asir_out,"\n");
 }  }
   
Line 1125  NODE *h;
Line 1088  NODE *h;
         NODE r,t,top;          NODE r,t,top;
         int n,i,j;          int n,i,j;
         int *w;          int *w;
         DP g;          DP g,p;
         struct oEGT tmp0,tmp1;          struct oEGT tmp0,tmp1;
   
         if ( NoRA ) {          if ( NoRA ) {
                 *h = in; return;                  *h = in; return;
         }          }
         if ( Print || PrintShort ) {          if ( DP_Print || DP_PrintShort ) {
                 fprintf(asir_out,"reduceall\n"); fflush(asir_out);                  fprintf(asir_out,"reduceall\n"); fflush(asir_out);
         }          }
         r = NODE_sortbi(in,0);          r = NODE_sortbi(in,0);
Line 1147  NODE *h;
Line 1110  NODE *h;
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 if ( PCoeffs )                  if ( PCoeffs )
                         dp_nf_mod(top,ps[w[i]],ps,m,1,&g);                          dp_nf_mod(top,ps[w[i]],ps,m,1,&g);
                 else                  else {
                         _dp_nf_mod(top,ps[w[i]],ps,m,1,&g);                          dpto_dp(ps[w[i]],&p);
                           _dp_nf_mod_destructive(top,p,ps,m,1,&g);
                   }
                 get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);
                 if ( Print || PrintShort ) {                  if ( DP_Print || DP_PrintShort ) {
                         fprintf(asir_out,"."); fflush(asir_out);                          fprintf(asir_out,"."); fflush(asir_out);
                 }                  }
                 w[i] = newps_mod(g,m);                  w[i] = newps_mod(g,m);
Line 1159  NODE *h;
Line 1124  NODE *h;
                 MKNODE(t,(pointer)w[j],top); top = t;                  MKNODE(t,(pointer)w[j],top); top = t;
         }          }
         *h = top;          *h = top;
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"\n");                  fprintf(asir_out,"\n");
 }  }
   
Line 1184  NODE subst;
Line 1149  NODE subst;
                         ps[psn] = a;                          ps[psn] = a;
                 else                  else
                         ps[psn] = 0;                          ps[psn] = 0;
                 dp_save(psn,a);                  dp_save(psn,(Obj)a,0);
         } else          } else
                 ps[psn] = a;                  ps[psn] = a;
         psh[psn] = BDY(a)->dl;          psh[psn] = BDY(a)->dl;
Line 1192  NODE subst;
Line 1157  NODE subst;
         psc[psn] = BDY(a)->c;          psc[psn] = BDY(a)->c;
         if ( m )          if ( m )
                 _dp_mod(a,m,subst,&psm[psn]);                  _dp_mod(a,m,subst,&psm[psn]);
           if ( GenTrace ) {
                   NODE tn,tr,tr1;
                   LIST trace;
   
                   /* reverse the TraceList */
                   tn = TraceList;
                   for ( tr = 0; tn; tn = NEXT(tn) ) {
                           MKNODE(tr1,BDY(tn),tr); tr = tr1;
                   }
                   MKLIST(trace,tr);
                   if ( OXCheck >= 0 ) {
                           NODE arg;
                           Q q1,q2;
                           STRING fname;
                           Obj dmy;
   
                           STOQ(OXCheck,q1);
                           MKSTR(fname,"check_trace");
                           STOQ(psn,q2);
                           arg = mknode(5,q1,fname,a,q2,trace);
                           Pox_cmo_rpc(arg,&dmy);
                   } else
                           dp_save(psn,(Obj)trace,"t");
                   TraceList = 0;
           }
         return psn++;          return psn++;
 }  }
   
Line 1267  NODE f,*g;
Line 1257  NODE f,*g;
         }          }
         for ( top = 0, i = n-1; i >= 0; i-- )          for ( top = 0, i = n-1; i >= 0; i-- )
                 if ( r[i] >= 0 ) {                  if ( r[i] >= 0 ) {
                         dp_load(r[i],&ps[r[i]]); dp_dehomo(ps[r[i]],&u); j = newps(u,0,0);                          dp_load(r[i],&ps[r[i]]); dp_dehomo(ps[r[i]],&u);
                           if ( GenTrace ) {
                                   Q q;
                                   LIST hist;
                                   NODE node;
   
                                   STOQ(r[i],q);
                                   node = mknode(4,0,q,0,0);
                                   MKLIST(hist,node);
                                   MKNODE(TraceList,hist,0);
                           }
                           j = newps(u,0,0);
                         MKNODE(t,j,top); top = t;                          MKNODE(t,j,top); top = t;
                 }                  }
         *g = top;          *g = top;
Line 1355  NODE subst;
Line 1356  NODE subst;
         struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1,tmp0,tmp1;          struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1,tmp0,tmp1;
         int skip_nf_flag;          int skip_nf_flag;
         double t_0;          double t_0;
           Q q;
         int new_sugar;          int new_sugar;
         static prev_sugar = -1;          static prev_sugar = -1;
   
Line 1382  NODE subst;
Line 1384  NODE subst;
                 if ( m ) {                  if ( m ) {
                         get_eg(&tspm0);                          get_eg(&tspm0);
                         _dp_sp_mod_dup(psm[l->dp1],psm[l->dp2],m,&h);                          _dp_sp_mod_dup(psm[l->dp1],psm[l->dp2],m,&h);
                         new_sugar = h->sugar;                          if ( h )
                                   new_sugar = h->sugar;
                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1);                          get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1);
                         get_eg(&tnfm0);                          get_eg(&tnfm0);
                         _dp_nf_mod_destructive(gall,h,psm,m,0,&nfm);                          _dp_nf_mod_destructive(gall,h,psm,m,0,&nfm);
Line 1404  NODE subst;
Line 1407  NODE subst;
                                 }                                  }
                         } else                          } else
                                 dp_sp(ps[l->dp1],ps[l->dp2],&h);                                  dp_sp(ps[l->dp1],ps[l->dp2],&h);
                         new_sugar = h->sugar;                          if ( GenTrace ) {
                                   STOQ(l->dp1,q); ARG1(BDY((LIST)BDY(NEXT(TraceList)))) = q;
                                   STOQ(l->dp2,q); ARG1(BDY((LIST)BDY(TraceList))) = q;
                           }
                           if ( h )
                                   new_sugar = h->sugar;
                         get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);                          get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);
                         get_eg(&tnf0);                          get_eg(&tnf0);
                         t_0 = get_rtime();                          t_0 = get_rtime();
Line 1416  NODE subst;
Line 1424  NODE subst;
 #else  #else
                                 _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);                                  _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);
 #endif  #endif
                         if ( Print )                          if ( DP_Print )
                                 fprintf(asir_out,"(%.3g)",get_rtime()-t_0);                                  fprintf(asir_out,"(%.3g)",get_rtime()-t_0);
                         get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);                          get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);
                 } else                  } else
Line 1443  skip_nf:
Line 1451  skip_nf:
                                         mag += p_mag((P)mp->c);                                          mag += p_mag((P)mp->c);
                                 Max_mag = MAX(Max_mag,mag);                                  Max_mag = MAX(Max_mag,mag);
                         }                          }
                         if ( Print ) {                          if ( DP_Print ) {
                                 if ( !prev )                                  if ( !prev )
                                         fprintf(asir_out,"\n");                                          fprintf(asir_out,"\n");
                                 print_split_e(&tnf0,&tnf1); print_split_e(&tpz0,&tpz1);                                  print_split_e(&tnf0,&tnf1); print_split_e(&tpz0,&tpz1);
Line 1454  skip_nf:
Line 1462  skip_nf:
                                 if ( ShowMag )                                  if ( ShowMag )
                                         fprintf(asir_out,",mag=%d",mag);                                          fprintf(asir_out,",mag=%d",mag);
                                 fprintf(asir_out,"\n"); fflush(asir_out);                                  fprintf(asir_out,"\n"); fflush(asir_out);
                         } else if ( PrintShort ) {                          } else if ( DP_PrintShort ) {
                                 fprintf(asir_out,"+"); fflush(asir_out);                                  fprintf(asir_out,"+"); fflush(asir_out);
                         }                          }
                         prev = 1;                          prev = 1;
Line 1462  skip_nf:
Line 1470  skip_nf:
                         if ( m )                          if ( m )
                                 add_eg(&eg_znfm,&tnfm0,&tnfm1);                                  add_eg(&eg_znfm,&tnfm0,&tnfm1);
                         ZR++;                          ZR++;
                         if ( Print || PrintShort ) {                          if ( DP_Print || DP_PrintShort ) {
                                 if ( new_sugar != prev_sugar ) {                                  if ( new_sugar != prev_sugar ) {
                                         fprintf(asir_out,"[%d]",new_sugar);                                          fprintf(asir_out,"[%d]",new_sugar);
                                         prev_sugar = new_sugar;                                          prev_sugar = new_sugar;
Line 1471  skip_nf:
Line 1479  skip_nf:
                         }                          }
                 }                  }
         }          }
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"gb done\n");                  fprintf(asir_out,"gb done\n");
         return g;          return g;
 }  }
Line 1547  NODE dlist;
Line 1555  NODE dlist;
                                 return 0;                                  return 0;
                         g = updbase(g,nh);                          g = updbase(g,nh);
                         gall = append_one(gall,nh);                          gall = append_one(gall,nh);
                         if ( Print ) {                          if ( DP_Print ) {
                                 if ( !prev )                                  if ( !prev )
                                         fprintf(asir_out,"\n");                                          fprintf(asir_out,"\n");
                                 print_split_eg(&tnf0,&tnf1); fflush(asir_out);                                  print_split_eg(&tnf0,&tnf1); fflush(asir_out);
Line 1559  NODE dlist;
Line 1567  NODE dlist;
                         if ( m )                          if ( m )
                                 add_eg(&eg_znfm,&tnfm0,&tnfm1);                                  add_eg(&eg_znfm,&tnfm0,&tnfm1);
                         ZR++;                          ZR++;
                         if ( Print ) {                          if ( DP_Print ) {
                                 fprintf(asir_out,"."); fflush(asir_out); prev = 0;                                  fprintf(asir_out,"."); fflush(asir_out); prev = 0;
                         }                          }
                 }                  }
         }          }
         if ( Print )          if ( DP_Print )
                 fprintf(asir_out,"gb done\n");                  fprintf(asir_out,"gb done\n");
         return g;          return g;
 }  }
Line 1611  int m;
Line 1619  int m;
                                 return 0;                                  return 0;
                         d = updpairs(d,g,nh);                          d = updpairs(d,g,nh);
                         g = updbase(g,nh);                          g = updbase(g,nh);
                         if ( InterReduce )  
                                 interreduce_mod(g,nh,m);  
                         gall = append_one(gall,nh);                          gall = append_one(gall,nh);
                         if ( Print ) {                          if ( DP_Print ) {
                                 if ( !prev )                                  if ( !prev )
                                         fprintf(asir_out,"\n");                                          fprintf(asir_out,"\n");
                                 print_split_eg(&tnfm0,&tnfm1); fflush(asir_out);                                  print_split_eg(&tnfm0,&tnfm1); fflush(asir_out);
                                 fprintf(asir_out,"(%d,%d),nb=%d,nab=%d,rp=%d,sugar=%d",l->dp1,l->dp2,length(g),length(gall),DPPlength(d),pss[nh]);                                  fprintf(asir_out,"(%d,%d),nb=%d,nab=%d,rp=%d,sugar=%d",l->dp1,l->dp2,length(g),length(gall),DPPlength(d),pss[nh]);
                                 printdl(psh[nh]); fprintf(asir_out,"\n"); fflush(asir_out);                                  printdl(psh[nh]); fprintf(asir_out,"\n"); fflush(asir_out);
                         } else if ( PrintShort ) {                          } else if ( DP_PrintShort ) {
                                 fprintf(asir_out,"+"); fflush(asir_out);                                  fprintf(asir_out,"+"); fflush(asir_out);
                         }                          }
                         prev = 1;                          prev = 1;
                 } else {                  } else {
                         add_eg(&eg_znfm,&tnfm0,&tnfm1);                          add_eg(&eg_znfm,&tnfm0,&tnfm1);
                         ZR++;                          ZR++;
                         if ( Print || PrintShort ) {                          if ( DP_Print || DP_PrintShort ) {
                                 fprintf(asir_out,"."); fflush(asir_out); prev = 0;                                  fprintf(asir_out,"."); fflush(asir_out); prev = 0;
                         }                          }
                 }                  }
         }          }
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"gb_mod done\n");                  fprintf(asir_out,"gb_mod done\n");
         return g;          return g;
 }  }
   
 void interreduce_mod(g,n,m)  
 NODE g;  
 int n,m;  
 {  
         DP nf;  
         NODE gn,t;  
         int i;  
   
         MKNODE(gn,(pointer)n,0);  
         if ( PCoeffs )  
                 for ( t = g; t; t = NEXT(t) ) {  
                         i = (int)BDY(t);  
                         if ( i != n ) {  
                                 dp_nf_mod(gn,ps[i],ps,m,1,&nf); ps[i] = nf;  
                         }  
                 }  
         else  
                 for ( t = g; t; t = NEXT(t) ) {  
                         i = (int)BDY(t);  
                         if ( i != n ) {  
                                 _dp_nf_mod(gn,ps[i],ps,m,1,&nf); ps[i] = nf;  
                         }  
                 }  
 }  
   
 void _dp_nf_mod(b,g,ps,mod,full,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int mod,full;  
 DP *rp;  
 {  
         DP u,p,d,s,t;  
         NODE l;  
         MP m,mr;  
         int sugar,psugar;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dp_redble(g,p = ps[(int)BDY(l)]) ) {  
                                 _dp_red_mod(g,p,mod,&u);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 break;  
                         }  
                 }  
                 if ( u )  
                         g = u;  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         _addmd(CO,mod,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 void _dp_nf(b,g,ps,full,rp)  void _dp_nf(b,g,ps,full,rp)
 NODE b;  NODE b;
 DP g;  DP g;
Line 1718  DP *ps;
Line 1650  DP *ps;
 int full;  int full;
 DP *rp;  DP *rp;
 {  {
         DP u,p,d,s,t;          DP u,p,d,s,t,mult;
         P dmy;          P coef;
         NODE l;          NODE l;
         MP m,mr;          MP m,mr;
         int sugar,psugar;          int sugar,psugar;
Line 1732  DP *rp;
Line 1664  DP *rp;
                 for ( u = 0, l = b; l; l = NEXT(l) ) {                  for ( u = 0, l = b; l; l = NEXT(l) ) {
                         if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {                          if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {
                                 dp_load((int)BDY(l),&p);                                  dp_load((int)BDY(l),&p);
                                 dp_red(d,g,p,&t,&u,&dmy);                                  /* t+u = coef*(d+g) - mult*p (t = coef*d) */
                                   dp_red(d,g,p,&t,&u,&coef,&mult);
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;                                  psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
                                 sugar = MAX(sugar,psugar);                                  sugar = MAX(sugar,psugar);
                                   if ( GenTrace ) {
                                           LIST hist;
                                           Q cq;
                                           NODE node,node0;
   
                                           STOQ((int)BDY(l),cq);
                                           node0 = mknode(4,coef,cq,mult,ONE);
                                           MKLIST(hist,node0);
                                           MKNODE(node,hist,TraceList); TraceList = node;
                                   }
                                 if ( !u ) {                                  if ( !u ) {
                                         if ( d )                                          if ( d )
                                                 d->sugar = sugar;                                                  d->sugar = sugar;
Line 1767  DP *rp;
Line 1710  DP *rp;
   
 double pz_t_e, pz_t_d, pz_t_d1, pz_t_c, im_t_s, im_t_r;  double pz_t_e, pz_t_d, pz_t_d1, pz_t_c, im_t_s, im_t_r;
   
   extern int GenTrace;
   extern NODE TraceList;
   
 void _dp_nf_ptozp(b,g,ps,full,multiple,r)  void _dp_nf_ptozp(b,g,ps,full,multiple,r)
 NODE b;  NODE b;
 DP g;  DP g;
Line 1788  DP *r;
Line 1734  DP *r;
         extern int kara_mag;          extern int kara_mag;
         double get_rtime();          double get_rtime();
         double t_0,t_00,tt,ttt,t_p,t_m,t_m1,t_m2,t_s,t_g,t_a;          double t_0,t_00,tt,ttt,t_p,t_m,t_m1,t_m2,t_s,t_g,t_a;
           LIST hist;
           NODE node;
           Q rcred,mrcred;
   
         if ( !g ) {          if ( !g ) {
                 *r = 0; return;                  *r = 0; return;
Line 1807  DP *r;
Line 1756  DP *r;
         dc = 0; dp = 0; rc = ONE; rp = g;          dc = 0; dp = 0; rc = ONE; rp = g;
         MKSTR(imul,"dp_imul_index");          MKSTR(imul,"dp_imul_index");
   
           /* g = dc*dp+rc*rp */
         for ( ; rp; ) {          for ( ; rp; ) {
                 for ( u = 0, l = b; l; l = NEXT(l) ) {                  for ( u = 0, l = b; l; l = NEXT(l) ) {
                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {                          if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {
Line 1820  DP *r;
Line 1770  DP *r;
   
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
                                 dp_subd(rp,red,&shift);                                  dp_subd(rp,red,&shift);
 #if INET  
                                 if ( Dist && ndist && HMAG(red) > kara_bit ) {                                  if ( Dist && ndist && HMAG(red) > kara_bit ) {
                                         NODE n0,n1,n2,n3;                                          NODE n0,n1,n2,n3;
                                         int i,s,id;                                          int i,s,id;
                                         Obj dmy;                                          Obj dmy;
                                         Q ind;                                          Q ind;
   
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"d");                                                  fprintf(asir_out,"d");
                                         i = (int)BDY(l); STOQ(i,ind);                                          i = (int)BDY(l); STOQ(i,ind);
                                         chsgnp((P)cred,(P *)&mcred);                                          chsgnp((P)cred,(P *)&mcred);
Line 1838  DP *r;
Line 1787  DP *r;
                                         muldc(CO,rp,(P)cr,&t);                                          muldc(CO,rp,(P)cr,&t);
                                         NEXT(n0)=0;                                          NEXT(n0)=0;
                                         Pox_pop_local(n0,&t1);                                          Pox_pop_local(n0,&t1);
                                 } else                                  } else {
 #endif  
                                 {  
 /*  /*
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"l");                                                  fprintf(asir_out,"l");
 */  */
                                         t_00 = get_rtime();                                          t_00 = get_rtime();
Line 1861  DP *r;
Line 1808  DP *r;
   
                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;                                  psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;
                                 sugar = MAX(sugar,psugar);                                  sugar = MAX(sugar,psugar);
                                   if ( GenTrace ) {
                                           /* u = cr*rp + (-cred)*shift*red */
                                           STOQ((int)BDY(l),cq);
                                           node = mknode(4,cr,cq,0,0);
                                           mulq(cred,rc,&rcred);
                                           chsgnnum((Num)rcred,(Num *)&mrcred);
                                           muldc(CO,shift,(P)mrcred,(DP *)&ARG2(node));
                                           MKLIST(hist,node);
                                   }
                                 if ( !u ) {                                  if ( !u ) {
                                         if ( dp )                                          if ( dp )
                                                 dp->sugar = sugar;                                                  dp->sugar = sugar;
                                         *r = dp;                                          *r = dp;
                                           if ( GenTrace ) {
                                                   ARG3(BDY(hist)) = ONE;
                                                   MKNODE(node,hist,TraceList); TraceList = node;
                                           }
                                         goto final;                                          goto final;
                                 }                                  }
                                 break;                                  break;
Line 1873  DP *r;
Line 1833  DP *r;
                 if ( u ) {                  if ( u ) {
                         if ( HMAG(u) > hmag ) {                          if ( HMAG(u) > hmag ) {
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
 #if INET  
                                 if ( Dist && HMAG(u) > kara_bit ) {                                  if ( Dist && HMAG(u) > kara_bit ) {
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"D");                                                  fprintf(asir_out,"D");
                                         dp_ptozp_d(dist,ndist,u,&t);                                          dp_ptozp_d(dist,ndist,u,&t);
                                 } else {                                  } else {
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"L");                                                  fprintf(asir_out,"L");
                                         dp_ptozp_d(0,0,u,&t);                                          dp_ptozp_d(0,0,u,&t);
                                 }                                  }
 #else  
                                 dp_ptozp(u,&t); /* XXX */  
 #endif  
                                 tt = get_rtime()-t_0; t_g += tt;                                  tt = get_rtime()-t_0; t_g += tt;
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);                                  divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);
                                 if ( !dp_fcoeffs && Print ) {                                  if ( !dp_fcoeffs && DP_Print ) {
                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));                                          fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
                                         fflush(asir_out);                                          fflush(asir_out);
                                 }                                  }
Line 1901  DP *r;
Line 1857  DP *r;
                                 tt = get_rtime()-t_0; t_a += tt;                                  tt = get_rtime()-t_0; t_a += tt;
                                 rp = t;                                  rp = t;
                                 hmag = multiple*HMAG(rp)/denom;                                  hmag = multiple*HMAG(rp)/denom;
                                   if ( GenTrace ) {
                                           NTOQ(gn,1,gcd);
                                           ARG3(BDY(hist)) = (pointer)gcd;
                                           MKNODE(node,hist,TraceList); TraceList = node;
                                   }
                         } else {                          } else {
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
                                 mulq(cr,dc,&dcq); dc = dcq;                                  mulq(cr,dc,&dcq); dc = dcq;
                                 tt = get_rtime()-t_0; t_a += tt;                                  tt = get_rtime()-t_0; t_a += tt;
                                 rp = u;                                  rp = u;
                                   if ( GenTrace ) {
                                           ARG3(BDY(hist)) = (pointer)ONE;
                                           MKNODE(node,hist,TraceList); TraceList = node;
                                   }
                         }                          }
                 } else if ( !full ) {                  } else if ( !full ) {
                         if ( rp ) {                          if ( rp ) {
Line 1929  DP *r;
Line 1894  DP *r;
                         tt = get_rtime()-t_0; t_a += tt;                          tt = get_rtime()-t_0; t_a += tt;
                 }                  }
         }          }
           if ( GenTrace ) {
                   mulq(ARG3(BDY((LIST)BDY(TraceList))),dc,&cq);
                   ARG3(BDY((LIST)BDY(TraceList))) = (pointer)cq;
           }
         if ( dp )          if ( dp )
                 dp->sugar = sugar;                  dp->sugar = sugar;
         *r = dp;          *r = dp;
 final:  final:
         if ( Print )          if ( DP_Print )
                 fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",                  fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",
                         t_p,t_m,t_m1,t_m2,t_s,                          t_p,t_m,t_m1,t_m2,t_s,
                         t_g,t_a,                          t_g,t_a,
Line 2004  DP *r;
Line 1973  DP *r;
                                 t_00 = get_rtime();                                  t_00 = get_rtime();
                                 if ( Dist && ndist                                  if ( Dist && ndist
                                         && HMAG(rp) > mpi_mag && p_mag((P)cr) > mpi_mag ) {                                          && HMAG(rp) > mpi_mag && p_mag((P)cr) > mpi_mag ) {
                                         if ( Print ) fprintf(asir_out,"~");                                          if ( DP_Print ) fprintf(asir_out,"~");
                                         dp_imul_d(rp,cr,&t);                                          dp_imul_d(rp,cr,&t);
                                 } else {                                  } else {
                                         if ( Print ) fprintf(asir_out,"_");                                          if ( DP_Print ) fprintf(asir_out,"_");
                                         muldc(CO,rp,(P)cr,&t);                                          muldc(CO,rp,(P)cr,&t);
                                 }                                  }
                                 ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);                                  ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);
Line 2016  DP *r;
Line 1985  DP *r;
                                 chsgnp((P)cred,(P *)&mcred);                                  chsgnp((P)cred,(P *)&mcred);
                                 if ( Dist && ndist                                  if ( Dist && ndist
                                         && HMAG(red) > mpi_mag && p_mag((P)mcred) > mpi_mag ) {                                          && HMAG(red) > mpi_mag && p_mag((P)mcred) > mpi_mag ) {
                                         if ( Print ) fprintf(asir_out,"=");                                          if ( DP_Print ) fprintf(asir_out,"=");
                                         dp_imul_d(red,mcred,&t1);                                          dp_imul_d(red,mcred,&t1);
                                 } else {                                  } else {
                                         if ( Print ) fprintf(asir_out,"_");                                          if ( DP_Print ) fprintf(asir_out,"_");
                                         muldc(CO,red,(P)mcred,&t1);                                          muldc(CO,red,(P)mcred,&t1);
                                 }                                  }
                                 ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);                                  ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);
Line 2045  DP *r;
Line 2014  DP *r;
                         if ( HMAG(u) > hmag ) {                          if ( HMAG(u) > hmag ) {
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
                                 if ( Dist && HMAG(u) > mpi_mag ) {                                  if ( Dist && HMAG(u) > mpi_mag ) {
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"D");                                                  fprintf(asir_out,"D");
                                         dp_ptozp_d(dist,ndist,u,&t);                                          dp_ptozp_d(dist,ndist,u,&t);
                                 } else {                                  } else {
                                         if ( Print )                                          if ( DP_Print )
                                                 fprintf(asir_out,"L");                                                  fprintf(asir_out,"L");
                                         dp_ptozp_d(0,0,u,&t);                                          dp_ptozp_d(0,0,u,&t);
                                 }                                  }
                                 tt = get_rtime()-t_0; t_g += tt;                                  tt = get_rtime()-t_0; t_g += tt;
                                 t_0 = get_rtime();                                  t_0 = get_rtime();
                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);                                  divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);
                                 if ( Print ) {                                  if ( DP_Print ) {
                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));                                          fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
                                         fflush(asir_out);                                          fflush(asir_out);
                                 }                                  }
Line 2100  DP *r;
Line 2069  DP *r;
                 dp->sugar = sugar;                  dp->sugar = sugar;
         *r = dp;          *r = dp;
 final:  final:
         if ( Print )          if ( DP_Print )
                 fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",                  fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",
                         t_p,t_m,t_m1,t_m2,t_s,                          t_p,t_m,t_m1,t_m2,t_s,
                         t_g,t_a,                          t_g,t_a,
Line 2451  NODE f;
Line 2420  NODE f;
                 g = updbase(g,i);                  g = updbase(g,i);
                 gall = append_one(gall,i);                  gall = append_one(gall,i);
         }          }
         if ( Print || PrintShort ) {          if ( DP_Print || DP_PrintShort ) {
                 fprintf(asir_out,"gbcheck total %d pairs\n",DPPlength(d)); fflush(asir_out);                  fprintf(asir_out,"gbcheck total %d pairs\n",DPPlength(d)); fflush(asir_out);
         }          }
         while ( d ) {          while ( d ) {
Line 2460  NODE f;
Line 2429  NODE f;
                 dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2); dp_sp(dp1,dp2,&h);                  dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2); dp_sp(dp1,dp2,&h);
                 _dp_nf(gall,h,ps,1,&nf);                  _dp_nf(gall,h,ps,1,&nf);
                 get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1);
                 if ( Print || PrintShort ) {                  if ( DP_Print || DP_PrintShort ) {
                         fprintf(asir_out,"."); fflush(asir_out);                          fprintf(asir_out,"."); fflush(asir_out);
                 }                  }
                 if ( nf )                  if ( nf )
                         return 0;                          return 0;
         }          }
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"\n");                  fprintf(asir_out,"\n");
         return 1;          return 1;
 }  }
Line 2479  NODE f,x;
Line 2448  NODE f,x;
   
         if ( NoMC )          if ( NoMC )
                 return 1;                  return 1;
         if ( Print || PrintShort ) {          if ( DP_Print || DP_PrintShort ) {
                 fprintf(asir_out,"membercheck\n"); fflush(asir_out);                  fprintf(asir_out,"membercheck\n"); fflush(asir_out);
         }          }
         for ( ; f; f = NEXT(f) ) {          for ( ; f; f = NEXT(f) ) {
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 _dp_nf(x,(DP)BDY(f),ps,1,&g);                  _dp_nf(x,(DP)BDY(f),ps,1,&g);
                 get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1);
                 if ( Print ) {                  if ( DP_Print ) {
                         print_split_eg(&tmp0,&tmp1); fflush(asir_out);                          print_split_eg(&tmp0,&tmp1); fflush(asir_out);
                 } else if ( PrintShort ) {                  } else if ( DP_PrintShort ) {
                         fprintf(asir_out,"."); fflush(asir_out);                          fprintf(asir_out,"."); fflush(asir_out);
                 }                  }
                 if ( g )                  if ( g )
                         return 0;                          return 0;
         }          }
         if ( Print || PrintShort )          if ( DP_Print || DP_PrintShort )
                 fprintf(asir_out,"\n");                  fprintf(asir_out,"\n");
         return 1;          return 1;
 }  }
Line 2533  Obj name,value;
Line 2502  Obj name,value;
                 Top = v;                  Top = v;
         else if ( !strcmp(n,"ShowMag") )          else if ( !strcmp(n,"ShowMag") )
                 ShowMag = v;                  ShowMag = v;
         else if ( !strcmp(n,"PrintShort") )          else if ( !strcmp(n,"DP_PrintShort") )
                 PrintShort = v;                  DP_PrintShort = v;
         else if ( !strcmp(n,"Print") )          else if ( !strcmp(n,"DP_Print") )
                 Print = v;                  DP_Print = v;
         else if ( !strcmp(n,"Stat") )          else if ( !strcmp(n,"Stat") )
                 Stat = v;                  Stat = v;
         else if ( !strcmp(n,"Reverse") )          else if ( !strcmp(n,"Reverse") )
                 Reverse = v;                  Reverse = v;
         else if ( !strcmp(n,"InterReduce") )  
                 InterReduce = v;  
         else if ( !strcmp(n,"Multiple") )          else if ( !strcmp(n,"Multiple") )
                 Multiple = v;                  Multiple = v;
         else if ( !strcmp(n,"Denominator") )          else if ( !strcmp(n,"Denominator") )
                 Denominator = v;                  Denominator = v;
         else if ( !strcmp(n,"PtozpRA") )          else if ( !strcmp(n,"PtozpRA") )
                 PtozpRA = v;                  PtozpRA = v;
           else if ( !strcmp(n,"GenTrace") )
                   GenTrace = v;
           else if ( !strcmp(n,"OXCheck") )
                   OXCheck = v;
 }  }
   
 void dp_make_flaglist(list)  void dp_make_flaglist(list)
Line 2561  LIST *list;
Line 2532  LIST *list;
         STOQ(Multiple,v); MKNODE(n,v,0); MKSTR(name,"Multiple"); MKNODE(n1,name,n); n = n1;          STOQ(Multiple,v); MKNODE(n,v,0); MKSTR(name,"Multiple"); MKNODE(n1,name,n); n = n1;
         STOQ(Denominator,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Denominator"); MKNODE(n1,name,n); n = n1;          STOQ(Denominator,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Denominator"); MKNODE(n1,name,n); n = n1;
         MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); MKNODE(n1,name,n); n = n1;          MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); MKNODE(n1,name,n); n = n1;
         STOQ(InterReduce,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"InterReduce"); MKNODE(n1,name,n); n = n1;  
         STOQ(Reverse,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Reverse"); MKNODE(n1,name,n); n = n1;          STOQ(Reverse,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Reverse"); MKNODE(n1,name,n); n = n1;
         STOQ(Stat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Stat"); MKNODE(n1,name,n); n = n1;          STOQ(Stat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Stat"); MKNODE(n1,name,n); n = n1;
         STOQ(Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1;          STOQ(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"DP_Print"); MKNODE(n1,name,n); n = n1;
           STOQ(OXCheck,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"OXCheck"); MKNODE(n1,name,n); n = n1;
           STOQ(GenTrace,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"GenTrace"); MKNODE(n1,name,n); n = n1;
         STOQ(PtozpRA,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"PtozpRA"); MKNODE(n1,name,n); n = n1;          STOQ(PtozpRA,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"PtozpRA"); MKNODE(n1,name,n); n = n1;
         STOQ(ShowMag,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"ShowMag"); MKNODE(n1,name,n); n = n1;          STOQ(ShowMag,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"ShowMag"); MKNODE(n1,name,n); n = n1;
         STOQ(Top,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Top"); MKNODE(n1,name,n); n = n1;          STOQ(Top,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Top"); MKNODE(n1,name,n); n = n1;
Line 2584  LIST *list;
Line 2556  LIST *list;
   
 #define DELIM '/'  #define DELIM '/'
   
 #if defined(THINK_C)  void dp_save(index,p,prefix)
 #undef DELIM  
 #define DELIM ':'  
 #endif  
   
 void dp_save(index,p)  
 int index;  int index;
 DP p;  Obj p;
   char *prefix;
 {  {
         FILE *fp;          FILE *fp;
         char path[BUFSIZ];          char path[BUFSIZ];
   
         sprintf(path,"%s%c%d",Demand,DELIM,index);          if ( prefix )
 #if defined(VISUAL) || defined(THINK_C)                  sprintf(path,"%s%c%s%d",Demand,DELIM,prefix,index);
           else
                   sprintf(path,"%s%c%d",Demand,DELIM,index);
         if ( !(fp = fopen(path,"wb") ) )          if ( !(fp = fopen(path,"wb") ) )
 #else  
         if ( !(fp = fopen(path,"w") ) )  
 #endif  
                 error("dp_save : cannot open a file");                  error("dp_save : cannot open a file");
         savevl(fp,VC); saveobj(fp,(Obj)p); fclose(fp);          savevl(fp,VC); saveobj(fp,p); fclose(fp);
 }  }
   
 void dp_load(index,p)  void dp_load(index,p)
Line 2617  DP *p;
Line 2584  DP *p;
                 *p = ps[index];                  *p = ps[index];
         else {          else {
                 sprintf(path,"%s%c%d",Demand,DELIM,index);                  sprintf(path,"%s%c%d",Demand,DELIM,index);
 #if defined(VISUAL) || defined(THINK_C)  
                 if ( !(fp = fopen(path,"rb") ) )                  if ( !(fp = fopen(path,"rb") ) )
 #else  
                 if ( !(fp = fopen(path,"r") ) )  
 #endif  
                         error("dp_load : cannot open a file");                          error("dp_load : cannot open a file");
                 skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp);                  skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp);
         }          }
Line 2635  DP *p;
Line 2598  DP *p;
         char path[BUFSIZ];          char path[BUFSIZ];
   
         sprintf(path,"%s%c%d",Demand,DELIM,index);          sprintf(path,"%s%c%d",Demand,DELIM,index);
 #if defined(VISUAL) || defined(THINK_C)  
         if ( !(fp = fopen(path,"rb") ) )          if ( !(fp = fopen(path,"rb") ) )
 #else  
         if ( !(fp = fopen(path,"r") ) )  
 #endif  
                 return 0;                  return 0;
         else {          else {
                 skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); return 1;                  skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); return 1;
Line 2655  void init_stat() {
Line 2614  void init_stat() {
 }  }
   
 void print_stat() {  void print_stat() {
         if ( !Print && !Stat )          if ( !DP_Print && !Stat )
                 return;                  return;
         print_eg("UP",&eg_up); print_eg("SP",&eg_sp); print_eg("SPM",&eg_spm);          print_eg("UP",&eg_up); print_eg("SP",&eg_sp); print_eg("SPM",&eg_spm);
         print_eg("NF",&eg_nf); print_eg("NFM",&eg_nfm); print_eg("ZNFM",&eg_znfm);          print_eg("NF",&eg_nf); print_eg("NFM",&eg_nfm); print_eg("ZNFM",&eg_znfm);
Line 2663  void print_stat() {
Line 2622  void print_stat() {
         print_eg("RA",&eg_ra); print_eg("MC",&eg_mc); print_eg("GC",&eg_gc);          print_eg("RA",&eg_ra); print_eg("MC",&eg_mc); print_eg("GC",&eg_gc);
         fprintf(asir_out,"T=%d,B=%d M=%d F=%d D=%d ZR=%d NZR=%d\n",TP,NBP,NMP,NFP,NDP,ZR,NZR);          fprintf(asir_out,"T=%d,B=%d M=%d F=%d D=%d ZR=%d NZR=%d\n",TP,NBP,NMP,NFP,NDP,ZR,NZR);
 }  }
   
 /*  
  * Old codes  
  */  
   
 #if 0  
 void _dp_nf_ptozp(b,g,ps,full,multiple,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full,multiple;  
 DP *rp;  
 {  
         DP u,p,d,s,t,dmy;  
         NODE l;  
         MP m,mr;  
         int i,n;  
         int hmag,denom;  
         int sugar,psugar;  
         NODE dist;  
         int ndist;  
         int kara_bit;  
         extern int kara_mag;  
   
         if ( !g ) {  
                 *rp = 0; return;  
         }  
         denom = Denominator?Denominator:1;  
         hmag = multiple*HMAG(g)/denom;  
         kara_bit = kara_mag*27; /* XXX */  
         if ( Dist ) {  
                 dist = BDY(Dist);  
                 ndist = length(dist);  
         }  
         sugar = g->sugar;  
         for ( d = 0; g; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {  
                                 dp_load((int)BDY(l),&p);  
                                 dp_red(d,g,p,&t,&u,&dmy);  
                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 break;  
                         }  
                 }  
                 if ( u ) {  
                         g = u;  
                         if ( d ) {  
                                 if ( HMAG(d) > hmag ) {  
                                         if ( Dist && HMAG(g) > kara_bit )  
                                                 dp_ptozp2_d(dist,ndist,d,g,&t,&u);  
                                         else  
                                                 dp_ptozp2(d,g,&t,&u);  
                                         d = t; g = u;  
                                         hmag = multiple*HMAG(d)/denom;  
                                 }  
                         } else {  
                                 if ( HMAG(g) > hmag ) {  
 #if INET  
                                         if ( Dist && HMAG(g) > kara_bit ) {  
                                                 dp_ptozp_d(dist,ndist,g,&t);  
                                         } else  
 #endif  
                                                 dp_ptozp(g,&t);  
                                         g = t;  
                                         hmag = multiple*HMAG(g)/denom;  
                                 }  
                         }  
                 }  
                 else if ( !full ) {  
                         if ( g ) {  
                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;  
                         }  
                         *rp = g; return;  
                 } else {  
                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;  
                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 int criterion_2(dp1,dp2)  
 {  
         DP g1,g2,g,s1,s2;  
   
         monomial_gcd(ps[dp1],&g1); monomial_gcd(ps[dp2],&g2);  
         dp_gcd(g1,g2,&g);  
         dp_subd(ps[dp1],g,&s1); dp_subd(ps[dp2],g,&s2);  
         return _criterion_2(s1,s2);  
 }  
   
 int _criterion_2( dp1, dp2 )  
 DP dp1, dp2;  
 {  
         register int i, *d1, *d2;  
   
         d1 = BDY(dp1)->dl->d; d2 = BDY(dp2)->dl->d;  
         for ( i = CNVars; --i >= 0; d1++, d2++ )  
                 if ( (*d1 <= *d2 ? *d1 : *d2) > 0  ) return 0;  
         return 1;  
 }  
   
 void dp_gcd(p1,p2,rp)  
 DP p1,p2;  
 DP *rp;  
 {  
         int i,n,td;  
         DL d1,d2,d;  
         MP m;  
         DP s;  
   
         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;  
         NEWDL(d,n);  
         for ( i = 0, td = 0; i < n; i++ ) {  
                 d->d[i] = MIN(d1->d[i],d2->d[i]);  
                 td += d->d[i];  
         }  
         d->td = td;  
         NEWMP(m); m->dl = d; m->c = (P)ONE; NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td;  
         *rp = s;  
 }  
   
 void monomial_gcd(p,rp)  
 DP p;  
 DP *rp;  
 {  
         int n,i,td;  
         DL d,d1;  
         MP m;  
         DP s;  
   
         n = p->nv; m = BDY(p); d = m->dl;  
         NEWDL(d1,n);  
         for ( i = 0; i < n; i++ )  
                 d1->d[i] = d->d[i];  
         for ( m = NEXT(m); m; m = NEXT(m) ) {  
                 d = m->dl;  
                 for ( i = 0; i < n; i++ )  
                         d1->d[i] = MIN(d1->d[i],d->d[i]);  
         }  
         for ( i = 0, td = 0; i < n; i++ )  
                 td += d1->d[i];  
         NEWMP(m); m->dl = d1; m->c = (P)ONE; NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td;  
         *rp = s;  
 }  
 #endif  

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.13

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