[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.13 and 1.14

version 1.13, 2000/12/05 08:29:43 version 1.14, 2000/12/08 02:39:05
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/gr.c,v 1.12 2000/12/05 06:59:15 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.13 2000/12/05 08:29:43 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 74  typedef struct dp_pairs *DP_pairs;
Line 74  typedef struct dp_pairs *DP_pairs;
 #define NEXTDPP(r,c) \  #define NEXTDPP(r,c) \
 if(!(r)){NEWDPP(r);(c)=(r);}else{NEWDPP(NEXT(c));(c)=NEXT(c);}  if(!(r)){NEWDPP(r);(c)=(r);}else{NEWDPP(NEXT(c));(c)=NEXT(c);}
   
 struct oEGT eg_up,eg_sp,eg_spm,eg_nf,eg_nfm;  struct oEGT eg_nf,eg_nfm;
 struct oEGT eg_znfm,eg_pz,eg_np,eg_mp,eg_ra,eg_mc,eg_gc;  struct oEGT eg_znfm,eg_pz,eg_np,eg_ra,eg_mc,eg_gc;
 int TP,NBP,NMP,NFP,NDP,ZR,NZR;  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
   
 #define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))  #define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))
Line 85  extern int do_weyl;
Line 85  extern int do_weyl;
   
 extern DP_Print;  extern DP_Print;
   
   void dp_imul_d(DP,Q,DP *);
 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 *);
Line 104  DP_pairs criterion_M(DP_pairs);
Line 105  DP_pairs criterion_M(DP_pairs);
 DP_pairs criterion_B(DP_pairs,int);  DP_pairs criterion_B(DP_pairs,int);
 DP_pairs newpairs(NODE,int);  DP_pairs newpairs(NODE,int);
 DP_pairs updpairs(DP_pairs,NODE,int);  DP_pairs updpairs(DP_pairs,NODE,int);
 void _dp_nf_ptozp(NODE,DP,DP *,int,int,DP *);  void _dp_nf(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 *);  
 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 153  static int *pss;
Line 152  static int *pss;
 static int psn,pslen;  static int psn,pslen;
 static int NVars,CNVars,PCoeffs;  static int NVars,CNVars,PCoeffs;
 static VL VC;  static VL VC;
   
   int DP_Print = 0;
   int DP_Multiple = 0;
   LIST Dist = 0;
   int NoGCD = 0;
   int GenTrace = 0;
   int OXCheck = -1;
   
   static DP_NFStat = 0;
 static int NoSugar = 0;  static int NoSugar = 0;
 static int NoCriB = 0;  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 DP_Print = 0;  
 static int DP_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 Denominator = 1;  static int Denominator = 1;
 static int Top = 0;  static int Top = 0;
 static int Reverse = 0;  static int Reverse = 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;  
 int NoGCD = 0;  
 int GenTrace = 0;  
 int OXCheck = -1;  
 int doing_f4;  int doing_f4;
 NODE TraceList;  NODE TraceList;
   
Line 1057  NODE *h;
Line 1060  NODE *h;
                         MKLIST(hist,node);                          MKLIST(hist,node);
                         MKNODE(TraceList,hist,0);                          MKNODE(TraceList,hist,0);
                 }                  }
                 if ( !PtozpRA || !Multiple )                  _dp_nf(top,ps[w[i]],ps,1,PtozpRA?DP_Multiple:0,&g);
                         _dp_nf(top,ps[w[i]],ps,1,&g);  
                 else  
 #if MPI  
                         _dp_nf_ptozp_mpi(top,ps[w[i]],ps,1,Multiple,&g);  
 #else  
                         _dp_nf_ptozp(top,ps[w[i]],ps,1,Multiple,&g);  
 #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 ( DP_Print || DP_PrintShort ) {                  if ( DP_Print || DP_PrintShort ) {
Line 1378  NODE subst;
Line 1374  NODE subst;
                 gall = append_one(gall,i);                  gall = append_one(gall,i);
         }          }
         while ( d ) {          while ( d ) {
                 get_eg(&tmp0);                  l = minp(d,&d);
                 l = minp(d,&d1); d = d1;  
                 get_eg(&tmp1); add_eg(&eg_mp,&tmp0,&tmp1);  
                 if ( m ) {                  if ( m ) {
                         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);
                         if ( h )                          if ( h )
                                 new_sugar = h->sugar;                                  new_sugar = h->sugar;
                         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);
                         get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);                          get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);
                 } else                  } else
                         nfm = (DP)1;                          nfm = (DP)1;
                 if ( nfm ) {                  if ( nfm ) {
                         get_eg(&tsp0);  
                         if ( Demand ) {                          if ( Demand ) {
                                 if ( dp_load_t(psn,&nf) ) {                                  if ( dp_load_t(psn,&nf) ) {
                                         skip_nf_flag = 1;                                          skip_nf_flag = 1;
                                         get_eg(&tsp1); add_eg(&eg_nf,&tsp0,&tsp1);                                          tnf1=tsp1;
                                         tnf0=tsp0; tnf1=tsp1;  
                                         goto skip_nf;                                          goto skip_nf;
                                 } else {                                  } else {
                                         skip_nf_flag = 0;                                          skip_nf_flag = 0;
Line 1413  NODE subst;
Line 1403  NODE subst;
                         }                          }
                         if ( h )                          if ( h )
                                 new_sugar = h->sugar;                                  new_sugar = h->sugar;
                         get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);  
                         get_eg(&tnf0);                          get_eg(&tnf0);
                         t_0 = get_rtime();                          t_0 = get_rtime();
                         if ( !Multiple )                          _dp_nf(gall,h,ps,!Top,DP_Multiple,&nf);
                                 _dp_nf(gall,h,ps,!Top,&nf);  
                         else  
 #if MPI  
                                 _dp_nf_ptozp_mpi(gall,h,ps,!Top,Multiple,&nf);  
 #else  
                                 _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);  
 #endif  
                         if ( DP_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);
Line 1484  skip_nf:
Line 1466  skip_nf:
         return g;          return g;
 }  }
   
 NODE gbd(f,m,subst,dlist)  
 NODE f;  
 int m;  
 NODE subst;  
 NODE dlist;  
 {  
         int i,nh,prev;  
         NODE r,g,gall;  
         struct dp_pairs ol;  
         DP_pairs l;  
         NODE pair;  
         DP h,nf,nfm,dp1,dp2;  
         struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1;  
   
         prev = 1;  
         l = &ol;  
         if ( m ) {  
                 psm = (DP *)MALLOC(pslen*sizeof(DP));  
                 for ( i = 0; i < psn; i++ )  
                         if ( psh[i] && !validhc(psc[i],m,subst) )  
                                 return 0;  
                         else  
                                 _dp_mod(ps[i],m,subst,&psm[i]);  
         }  
         for ( gall = g = 0, r = f; r; r = NEXT(r) ) {  
                 i = (int)BDY(r);  
                 g = updbase(g,i);  
                 gall = append_one(gall,i);  
         }  
         while ( dlist ) {  
                 pair = BDY((LIST)BDY(dlist)); dlist = NEXT(dlist);  
                 l->dp1 = QTOS((Q)BDY(pair)); pair = NEXT(pair);  
                 l->dp2 = QTOS((Q)BDY(pair));  
                 if ( m ) {  
                         get_eg(&tspm0);  
                         _dp_sp_mod_dup(ps[l->dp1],ps[l->dp2],m,&h);  
                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1);  
                         get_eg(&tnfm0);  
                         _dp_nf_mod_destructive(gall,h,ps,m,!Top,&nf);  
                         get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);  
                 } else  
                         nfm = (DP)1;  
                 if ( nfm ) {  
                         get_eg(&tsp0);  
                         if ( Demand ) {  
                                 dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2);  
                                 dp_sp(dp1,dp2,&h);  
                         } else  
                                 dp_sp(ps[l->dp1],ps[l->dp2],&h);  
                         get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);  
                         get_eg(&tnfm0);  
                         get_eg(&tnf0);  
                         if ( !Multiple )  
                                 _dp_nf(gall,h,ps,!Top,&nf);  
                         else  
                                 _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);  
                         get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);  
                 } else  
                         nf = 0;  
                 if ( nf ) {  
                         NZR++;  
                         get_eg(&tpz0);  
                         prim_part(nf,0,&h);  
                         get_eg(&tpz1); add_eg(&eg_pz,&tpz0,&tpz1);  
                         get_eg(&tnp0);  
                         nh = newps(h,m,subst);  
                         get_eg(&tnp1); add_eg(&eg_np,&tnp0,&tnp1);  
                         if ( nh < 0 )  
                                 return 0;  
                         g = updbase(g,nh);  
                         gall = append_one(gall,nh);  
                         if ( DP_Print ) {  
                                 if ( !prev )  
                                         fprintf(asir_out,"\n");  
                                 print_split_eg(&tnf0,&tnf1); fflush(asir_out);  
                                 fprintf(asir_out,"(%d,%d),nb=%d,nab=%d,rp=%d,sugar=%d",l->dp1,l->dp2,length(g),length(gall),length(dlist),pss[nh]);  
                                 printdl(psh[nh]); fprintf(asir_out,"\n"); fflush(asir_out);  
                         }  
                         prev = 1;  
                 } else {  
                         if ( m )  
                                 add_eg(&eg_znfm,&tnfm0,&tnfm1);  
                         ZR++;  
                         if ( DP_Print ) {  
                                 fprintf(asir_out,"."); fflush(asir_out); prev = 0;  
                         }  
                 }  
         }  
         if ( DP_Print )  
                 fprintf(asir_out,"gb done\n");  
         return g;  
 }  
   
 NODE gb_mod(f,m)  NODE gb_mod(f,m)
 NODE f;  NODE f;
 int m;  int m;
Line 1596  int m;
Line 1485  int m;
                 gall = append_one(gall,i);                  gall = append_one(gall,i);
         }          }
         while ( d ) {          while ( d ) {
                 get_eg(&tmp0);                  l = minp(d,&d);
                 l = minp(d,&d1); d = d1;  
                 get_eg(&tmp1); add_eg(&eg_mp,&tmp0,&tmp1); get_eg(&tspm0);  
                 if ( PCoeffs ) {                  if ( PCoeffs ) {
                         dp_sp_mod(ps[l->dp1],ps[l->dp2],m,&h);                          dp_sp_mod(ps[l->dp1],ps[l->dp2],m,&h);
                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1); get_eg(&tnfm0);                          get_eg(&tnfm0);
                         dp_nf_mod(gall,h,ps,m,!Top,&nf);                          dp_nf_mod(gall,h,ps,m,!Top,&nf);
                 } else {                  } else {
                         _dp_sp_mod_dup(ps[l->dp1],ps[l->dp2],m,&h);                          _dp_sp_mod_dup(ps[l->dp1],ps[l->dp2],m,&h);
                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1); get_eg(&tnfm0);                          get_eg(&tnfm0);
                         _dp_nf_mod_destructive(gall,h,ps,m,!Top,&nf);                          _dp_nf_mod_destructive(gall,h,ps,m,!Top,&nf);
                 }                  }
                 get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);                  get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);
Line 1643  int m;
Line 1530  int m;
         return g;          return g;
 }  }
   
 void _dp_nf(b,g,ps,full,rp)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full;  
 DP *rp;  
 {  
         DP u,p,d,s,t,mult;  
         P coef;  
         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 ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {  
                                 dp_load((int)BDY(l),&p);  
                                 /* 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;  
                                 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 ( d )  
                                                 d->sugar = sugar;  
                                         *rp = d; return;  
                                 }  
                                 d = t;  
                                 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;  
                         addd(CO,d,t,&s); d = s;  
                         dp_rest(g,&t); g = t;  
                 }  
         }  
         if ( d )  
                 d->sugar = sugar;  
         *rp = d;  
 }  
   
 #define SAFENM(q) ((q)?NM(q):0)  
   
 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)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full,multiple;  
 DP *r;  
 {  
         DP u,dp,rp,t,t1,t2,red,shift;  
         Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;  
         N gn,tn,cn;  
         NODE l;  
         MP m,mr;  
         int hmag,denom;  
         int sugar,psugar;  
         NODE dist;  
         STRING imul;  
         int ndist;  
         int kara_bit;  
         extern int kara_mag;  
         double get_rtime();  
         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 ) {  
                 *r = 0; return;  
         }  
         pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;  
         t_p = t_m = t_m1 = t_m2 = t_s = t_g = t_a = 0;  
   
         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;  
   
         dc = 0; dp = 0; rc = ONE; rp = g;  
         MKSTR(imul,"dp_imul_index");  
   
         /* g = dc*dp+rc*rp */  
         for ( ; rp; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {  
                                 t_0 = get_rtime();  
                                 dp_load((int)BDY(l),&red);  
                                 hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;  
                                 gcdn(NM(hr),NM(hred),&gn);  
                                 divsn(NM(hred),gn,&tn); NTOQ(tn,SGN(hred),cr);  
                                 divsn(NM(hr),gn,&tn); NTOQ(tn,SGN(hr),cred);  
                                 tt = get_rtime()-t_0; t_p += tt;  
   
                                 t_0 = get_rtime();  
                                 dp_subd(rp,red,&shift);  
                                 if ( Dist && ndist && HMAG(red) > kara_bit ) {  
                                         NODE n0,n1,n2,n3;  
                                         int i,s,id;  
                                         Obj dmy;  
                                         Q ind;  
   
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"d");  
                                         i = (int)BDY(l); STOQ(i,ind);  
                                         chsgnp((P)cred,(P *)&mcred);  
   
                                         MKNODE(n3,ind,0); MKNODE(n2,mcred,n3);  
                                         MKNODE(n1,imul,n2); MKNODE(n0,BDY(dist),n1);  
                                         Pox_rpc(n0,&dmy);  
                                         muldc(CO,rp,(P)cr,&t);  
                                         NEXT(n0)=0;  
                                         Pox_pop_local(n0,&t1);  
                                 } else {  
 /*  
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"l");  
 */  
                                         t_00 = get_rtime();  
                                         muldc(CO,rp,(P)cr,&t);  
                                         ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);  
                                         t_00 = get_rtime();  
                                         chsgnp((P)cred,(P *)&mcred);  
                                         muldc(CO,red,(P)mcred,&t1);  
                                         ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);  
                                 }  
                                 t_00 = get_rtime();  
                                 muld(CO,shift,t1,&t2);  
                                 addd(CO,t,t2,&u);  
                                 tt = get_rtime(); t_m += tt-t_0;  
                                 ttt = get_rtime(); t_s += ttt-t_00;  
   
                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;  
                                 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 ( dp )  
                                                 dp->sugar = sugar;  
                                         *r = dp;  
                                         if ( GenTrace ) {  
                                                 ARG3(BDY(hist)) = ONE;  
                                                 MKNODE(node,hist,TraceList); TraceList = node;  
                                         }  
                                         goto final;  
                                 }  
                                 break;  
                         }  
                 }  
                 if ( u ) {  
                         if ( HMAG(u) > hmag ) {  
                                 t_0 = get_rtime();  
                                 if ( Dist && HMAG(u) > kara_bit ) {  
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"D");  
                                         dp_ptozp_d(dist,ndist,u,&t);  
                                 } else {  
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"L");  
                                         dp_ptozp_d(0,0,u,&t);  
                                 }  
                                 tt = get_rtime()-t_0; t_g += tt;  
                                 t_0 = get_rtime();  
                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);  
                                 if ( !dp_fcoeffs && DP_Print ) {  
                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));  
                                         fflush(asir_out);  
                                 }  
                                 mulq(cr,dc,&dcq);  
                                 mulq(cont,rc,&rcq);  
                                 gcdn(SAFENM(dcq),SAFENM(rcq),&gn);  
                                 divsn(SAFENM(dcq),gn,&tn); NTOQ(tn,SGN(dcq),dc);  
                                 divsn(SAFENM(rcq),gn,&tn); NTOQ(tn,SGN(rcq),rc);  
                                 tt = get_rtime()-t_0; t_a += tt;  
                                 rp = t;  
                                 hmag = multiple*HMAG(rp)/denom;  
                                 if ( GenTrace ) {  
                                         NTOQ(gn,1,gcd);  
                                         ARG3(BDY(hist)) = (pointer)gcd;  
                                         MKNODE(node,hist,TraceList); TraceList = node;  
                                 }  
                         } else {  
                                 t_0 = get_rtime();  
                                 mulq(cr,dc,&dcq); dc = dcq;  
                                 tt = get_rtime()-t_0; t_a += tt;  
                                 rp = u;  
                                 if ( GenTrace ) {  
                                         ARG3(BDY(hist)) = (pointer)ONE;  
                                         MKNODE(node,hist,TraceList); TraceList = node;  
                                 }  
                         }  
                 } else if ( !full ) {  
                         if ( rp ) {  
                                 MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;  
                         }  
                         *r = rp;  
                         goto final;  
                 } else {  
                         t_0 = get_rtime();  
                         mulq((Q)BDY(rp)->c,rc,&c);  
                         gcdn(SAFENM(dc),SAFENM(c),&gn); NTOQ(gn,1,gcd);  
                         divsn(SAFENM(dc),gn,&tn); NTOQ(tn,SGN(dc),dcq);  
                         divsn(SAFENM(c),gn,&tn); NTOQ(tn,SGN(c),cq);  
                         muldc(CO,dp,(P)dcq,&t1);  
                         m = BDY(rp); NEWMP(mr); mr->dl = m->dl; mr->c = (P)cq;  
                         NEXT(mr) = 0; MKDP(rp->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,t,t1,&dp);  
                         dc = gcd;  
   
                         dp_rest(rp,&t); rp = t;  
                         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 )  
                 dp->sugar = sugar;  
         *r = dp;  
 final:  
         if ( DP_Print )  
                 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_g,t_a,  
                         pz_t_e, pz_t_d, pz_t_d1, pz_t_c);  
 }  
   
 void dp_imul_d();  
 void imulv();  
   
 void _dp_nf_ptozp_mpi(b,g,ps,full,multiple,r)  
 NODE b;  
 DP g;  
 DP *ps;  
 int full,multiple;  
 DP *r;  
 {  
         Obj dmy;  
         DP u,dp,rp,t,t1,t2,red,shift;  
         Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;  
         N gn,tn,cn;  
         NODE l,n0,n1,n2,n3;  
         MP m,mr;  
         int i,n;  
         int hmag,denom;  
         int sugar,psugar;  
         NODE dist;  
         STRING imul;  
         int ndist;  
         int kara_bit;  
         extern int kara_mag;  
         extern int mpi_mag;  
         Q ind;  
         int id;  
         double get_rtime();  
         double t_0,t_00,tt,ttt,t_p,t_m,t_m1,t_m2,t_s,t_g,t_a;  
   
         if ( !g ) {  
                 *r = 0; return;  
         }  
         pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;  
         t_p = t_m = t_m1 = t_m2 = t_s = t_g = t_a = 0;  
   
         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;  
   
         dc = 0; dp = 0; rc = ONE; rp = g;  
         MKSTR(imul,"dp_imul_index");  
   
         for ( ; rp; ) {  
                 for ( u = 0, l = b; l; l = NEXT(l) ) {  
                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {  
                                 t_0 = get_rtime();  
                                 dp_load((int)BDY(l),&red);  
                                 hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;  
                                 gcdn(NM(hr),NM(hred),&gn);  
                                 divsn(NM(hred),gn,&tn); NTOQ(tn,SGN(hred),cr);  
                                 divsn(NM(hr),gn,&tn); NTOQ(tn,SGN(hr),cred);  
                                 tt = get_rtime()-t_0; t_p += tt;  
   
                                 t_0 = get_rtime();  
                                 dp_subd(rp,red,&shift);  
                                 t_00 = get_rtime();  
                                 if ( Dist && ndist  
                                         && HMAG(rp) > mpi_mag && p_mag((P)cr) > mpi_mag ) {  
                                         if ( DP_Print ) fprintf(asir_out,"~");  
                                         dp_imul_d(rp,cr,&t);  
                                 } else {  
                                         if ( DP_Print ) fprintf(asir_out,"_");  
                                         muldc(CO,rp,(P)cr,&t);  
                                 }  
                                 ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);  
   
                                 t_00 = get_rtime();  
                                 chsgnp((P)cred,(P *)&mcred);  
                                 if ( Dist && ndist  
                                         && HMAG(red) > mpi_mag && p_mag((P)mcred) > mpi_mag ) {  
                                         if ( DP_Print ) fprintf(asir_out,"=");  
                                         dp_imul_d(red,mcred,&t1);  
                                 } else {  
                                         if ( DP_Print ) fprintf(asir_out,"_");  
                                         muldc(CO,red,(P)mcred,&t1);  
                                 }  
                                 ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);  
   
                                 t_00 = get_rtime();  
                                 muld(CO,shift,t1,&t2);  
                                 addd(CO,t,t2,&u);  
                                 tt = get_rtime(); t_m += tt-t_0;  
                                 ttt = get_rtime(); t_s += ttt-t_00;  
   
                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;  
                                 sugar = MAX(sugar,psugar);  
                                 if ( !u ) {  
                                         if ( dp )  
                                                 dp->sugar = sugar;  
                                         *r = dp;  
                                         goto final;  
                                 }  
                                 break;  
                         }  
                 }  
                 if ( u ) {  
                         if ( HMAG(u) > hmag ) {  
                                 t_0 = get_rtime();  
                                 if ( Dist && HMAG(u) > mpi_mag ) {  
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"D");  
                                         dp_ptozp_d(dist,ndist,u,&t);  
                                 } else {  
                                         if ( DP_Print )  
                                                 fprintf(asir_out,"L");  
                                         dp_ptozp_d(0,0,u,&t);  
                                 }  
                                 tt = get_rtime()-t_0; t_g += tt;  
                                 t_0 = get_rtime();  
                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);  
                                 if ( DP_Print ) {  
                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));  
                                         fflush(asir_out);  
                                 }  
                                 mulq(cr,dc,&dcq);  
                                 mulq(cont,rc,&rcq);  
                                 gcdn(SAFENM(dcq),SAFENM(rcq),&gn);  
                                 divsn(SAFENM(dcq),gn,&tn); NTOQ(tn,SGN(dcq),dc);  
                                 divsn(SAFENM(rcq),gn,&tn); NTOQ(tn,SGN(rcq),rc);  
                                 tt = get_rtime()-t_0; t_a += tt;  
                                 rp = t;  
                                 hmag = multiple*HMAG(rp)/denom;  
                         } else {  
                                 t_0 = get_rtime();  
                                 mulq(cr,dc,&dcq); dc = dcq;  
                                 tt = get_rtime()-t_0; t_a += tt;  
                                 rp = u;  
                         }  
                 } else if ( !full ) {  
                         if ( rp ) {  
                                 MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;  
                         }  
                         *r = rp;  
                         goto final;  
                 } else {  
                         t_0 = get_rtime();  
                         mulq((Q)BDY(rp)->c,(Q)rc,(Q *)&c);  
                         gcdn(SAFENM(dc),SAFENM(c),&gn); NTOQ(gn,1,gcd);  
                         divsn(SAFENM(dc),gn,&tn); NTOQ(tn,SGN(dc),dcq);  
                         divsn(SAFENM(c),gn,&tn); NTOQ(tn,SGN(c),cq);  
                         muldc(CO,dp,(P)dcq,&t1);  
                         m = BDY(rp); NEWMP(mr); mr->dl = m->dl; mr->c = (P)cq;  
                         NEXT(mr) = 0; MKDP(rp->nv,mr,t); t->sugar = mr->dl->td;  
                         addd(CO,t,t1,&dp);  
                         dc = gcd;  
   
                         dp_rest(rp,&t); rp = t;  
                         tt = get_rtime()-t_0; t_a += tt;  
                 }  
         }  
         if ( dp )  
                 dp->sugar = sugar;  
         *r = dp;  
 final:  
         if ( DP_Print )  
                 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_g,t_a,  
                         pz_t_e, pz_t_d, pz_t_d1, pz_t_c);  
 }  
   
 void dp_imul_d(p,q,rp)  
 DP p;  
 Q q;  
 DP *rp;  
 {  
         int nsep,ndist,i,j,k,l,n;  
         double t0,t1,t2;  
         Q *s;  
         pointer *b;  
         VECT c,cs,ri;  
         VECT *r;  
         MP m;  
         NODE tn,dist,n0,n1,n2;  
         Obj dmy;  
         STRING imul;  
   
         extern LIST Dist;  
   
         if ( !p || !q ) {  
                 *rp = 0; return;  
         }  
         dist = BDY(Dist);  
         for ( tn = dist, ndist = 0; tn; tn = NEXT(tn), ndist++ );  
         nsep = ndist + 1;  
         for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );  
         if ( n <= nsep ) {  
                 muldc(CO,p,(P)q,rp); return;  
         }  
         MKSTR(imul,"imulv");  
         t0 = get_rtime();  
         dp_dtov(p,&c);  
         sepvect(c,nsep,&cs);  
         r = (VECT *)CALLOC(nsep,sizeof(VECT *));  
         for ( i = 0, tn = dist, b = BDY(cs); i < ndist; i++, tn = NEXT(tn) ) {  
                 n0 = mknode(4,BDY(tn),imul,b[i],q);  
                 Pox_rpc(n0,&dmy);  
         }  
         t1 = get_rtime();  
         im_t_s += t1 - t0;  
         imulv(b[i],q,&r[i]);  
         t1 = get_rtime();  
         for ( i = 0, tn = dist; i < ndist; i++, tn = NEXT(tn) ) {  
                 MKNODE(n0,BDY(tn),0);  
                 Pox_pop_local(n0,&r[i]);  
                 if ( OID(r[i]) == O_ERR ) {  
                         printexpr(CO,(Obj)r[i]);  
                         error("dp_imul_d : aborted");  
                 }  
         }  
         t2 = get_rtime();  
         im_t_r += t2 - t1;  
         s = (Q *)CALLOC(n,sizeof(Q));  
         for ( i = j = 0; i < nsep; i++ ) {  
                 for ( k = 0, ri = r[i], l = ri->len; k < l; k++, j++ ) {  
                         s[j] = (Q)BDY(ri)[k];  
                 }  
         }  
         dp_vtod(s,p,rp);  
 }  
   
 void imulv(w,c,rp)  
 VECT w;  
 Q c;  
 VECT *rp;  
 {  
         int n,i;  
         VECT r;  
   
         n = w->len;  
         MKVECT(r,n); *rp = r;  
         for ( i = 0; i < n; i++ )  
                 mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);  
 }  
   
 DP_pairs updpairs( d, g, t)  DP_pairs updpairs( d, g, t)
 DP_pairs d;  DP_pairs d;
 NODE /* of index */ g;  NODE /* of index */ g;
Line 2160  int t;
Line 1540  int t;
         int dl,dl1;          int dl,dl1;
   
         if ( !g ) return d;          if ( !g ) return d;
         get_eg(&tup0);  
         if ( !NoCriB && d ) {          if ( !NoCriB && d ) {
                 dl = DPPlength(d);                  dl = DPPlength(d);
                 d = criterion_B( d, t );                  d = criterion_B( d, t );
Line 2186  int t;
Line 1565  int t;
         else          else
                 dd = d1;                  dd = d1;
         dl1 = DPPlength(dd); NDP += (dl-dl1);          dl1 = DPPlength(dd); NDP += (dl-dl1);
         get_eg(&tup1);  
         add_eg(&eg_up,&tup0,&tup1);  
         if ( !(nd = d) ) return dd;          if ( !(nd = d) ) return dd;
         while ( nd = NEXT(d1 = nd) ) ;          while ( nd = NEXT(d1 = nd) ) ;
         NEXT(d1) = dd;          NEXT(d1) = dd;
Line 2427  NODE f;
Line 1804  NODE f;
                 l = d; d = NEXT(d);                  l = d; d = NEXT(d);
                 get_eg(&tmp0);                  get_eg(&tmp0);
                 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,0,&nf);
                 get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1);
                 if ( DP_Print || DP_PrintShort ) {                  if ( DP_Print || DP_PrintShort ) {
                         fprintf(asir_out,"."); fflush(asir_out);                          fprintf(asir_out,"."); fflush(asir_out);
Line 2453  NODE f,x;
Line 1830  NODE f,x;
         }          }
         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,0,&g);
                 get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1);                  get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1);
                 if ( DP_Print ) {                  if ( DP_Print ) {
                         print_split_eg(&tmp0,&tmp1); fflush(asir_out);                          print_split_eg(&tmp0,&tmp1); fflush(asir_out);
Line 2502  Obj name,value;
Line 1879  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,"DP_PrintShort") )          else if ( !strcmp(n,"PrintShort") )
                 DP_PrintShort = v;                  DP_PrintShort = v;
         else if ( !strcmp(n,"DP_Print") )          else if ( !strcmp(n,"Print") )
                 DP_Print = v;                  DP_Print = v;
           else if ( !strcmp(n,"NFStat") )
                   DP_NFStat = 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,"Multiple") )          else if ( !strcmp(n,"Multiple") )
                 Multiple = v;                  DP_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") )
Line 2529  LIST *list;
Line 1908  LIST *list;
         STRING name,path;          STRING name,path;
         NODE n,n1;          NODE n,n1;
   
         STOQ(Multiple,v); MKNODE(n,v,0); MKSTR(name,"Multiple"); MKNODE(n1,name,n); n = n1;          STOQ(DP_Multiple,v); MKNODE(n,v,0); MKSTR(name,"DP_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(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(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"DP_Print"); MKNODE(n1,name,n); n = n1;          STOQ(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1;
           STOQ(DP_NFStat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"NFStat"); 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(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(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;
Line 2606  DP *p;
Line 1986  DP *p;
 }  }
   
 void init_stat() {  void init_stat() {
         init_eg(&eg_up); init_eg(&eg_sp); init_eg(&eg_spm);  
         init_eg(&eg_nf); init_eg(&eg_nfm); init_eg(&eg_znfm);          init_eg(&eg_nf); init_eg(&eg_nfm); init_eg(&eg_znfm);
         init_eg(&eg_pz); init_eg(&eg_np); init_eg(&eg_mp);          init_eg(&eg_pz); init_eg(&eg_np);
         init_eg(&eg_ra); init_eg(&eg_mc); init_eg(&eg_gc);          init_eg(&eg_ra); init_eg(&eg_mc); init_eg(&eg_gc);
         ZR = NZR = TP = NBP = NMP = NFP = NDP = 0;          ZR = NZR = TP = NBP = NFP = NDP = 0;
 }  }
   
 void print_stat() {  void print_stat() {
         if ( !DP_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("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);
         print_eg("PZ",&eg_pz); print_eg("NP",&eg_np); print_eg("MP",&eg_mp);          print_eg("PZ",&eg_pz); print_eg("NP",&eg_np);
         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);
 }  }
   
   /*
    * dp_nf used in gb()
    *
    */
   
   #define SAFENM(q) ((q)?NM(q):0)
   
   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(b,g,ps,full,multiple,r)
   NODE b;
   DP g;
   DP *ps;
   int full,multiple;
   DP *r;
   {
           DP u,dp,rp,t,t1,t2,red,shift;
           Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;
           N gn,tn,cn;
           NODE l;
           MP m,mr;
           int hmag,denom;
           int sugar,psugar;
           NODE dist;
           STRING imul;
           int ndist;
           int kara_bit;
           extern int mpi_mag;
           double get_rtime();
           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 ) {
                   *r = 0; return;
           }
           pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;
           t_p = t_m = t_m1 = t_m2 = t_s = t_g = t_a = 0;
   
           denom = Denominator?Denominator:1;
           hmag = multiple*HMAG(g)/denom;
           if ( Dist ) {
                   dist = BDY(Dist);
                   ndist = length(dist);
           }
           sugar = g->sugar;
   
           dc = 0; dp = 0; rc = ONE; rp = g;
           MKSTR(imul,"dp_imul_index");
   
           /* g = dc*dp+rc*rp */
           for ( ; rp; ) {
                   for ( u = 0, l = b; l; l = NEXT(l) ) {
                           if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {
                                   t_0 = get_rtime();
                                   dp_load((int)BDY(l),&red);
                                   hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;
                                   /*
                                    * hr = HC(rp), hred = HC(red)
                                    * cred = hr/GCD(hr,hred), cr = hred/GCD(hr,hred)
                                    */
                                   igcd_cofactor((Q)BDY(rp)->c,(Q)BDY(red)->c,&gcd,&cred,&cr);
                                   tt = get_rtime()-t_0; t_p += tt;
   
                                   t_0 = get_rtime();
                                   dp_subd(rp,red,&shift);
   
                                   t_00 = get_rtime();
                                   if ( Dist && ndist
                                           && HMAG(red) > mpi_mag
                                           && p_mag((P)cr) > mpi_mag ) {
                                           if ( DP_NFStat ) fprintf(asir_out,"~");
                                           dp_imul_d(rp,cr,&t);
                                   } else {
                                           if ( DP_NFStat ) fprintf(asir_out,"_");
                                           muldc(CO,rp,(P)cr,&t);
                                   }
                                   ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);
   
                                   t_00 = get_rtime();
                                   chsgnp((P)cred,(P *)&mcred);
                                   if ( Dist && ndist
                                           && HMAG(red) > mpi_mag
                                           && p_mag((P)mcred) > mpi_mag ) {
                                           if ( DP_NFStat ) fprintf(asir_out,"=");
                                           dp_imul_d(red,mcred,&t1);
                                   } else {
                                           if ( DP_NFStat ) fprintf(asir_out,"_");
                                           muldc(CO,red,(P)mcred,&t1);
                                   }
                                   ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);
   
                                   t_00 = get_rtime();
                                   muld(CO,shift,t1,&t2);
                                   addd(CO,t,t2,&u);
                                   tt = get_rtime(); t_m += tt-t_0;
                                   ttt = get_rtime(); t_s += ttt-t_00;
   
                                   psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;
                                   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 ( dp )
                                                   dp->sugar = sugar;
                                           *r = dp;
                                           if ( GenTrace ) {
                                                   ARG3(BDY(hist)) = ONE;
                                                   MKNODE(node,hist,TraceList); TraceList = node;
                                           }
                                           goto final;
                                   }
                                   break;
                           }
                   }
                   if ( u ) {
                           if ( multiple && HMAG(u) > hmag ) {
                                   t_0 = get_rtime();
                                   if ( Dist && HMAG(u) > mpi_mag ) {
                                           if ( DP_NFStat )
                                                   fprintf(asir_out,"D");
                                           dp_ptozp_d(dist,ndist,u,&t);
                                   } else {
                                           if ( DP_NFStat )
                                                   fprintf(asir_out,"L");
                                           dp_ptozp_d(0,0,u,&t);
                                   }
                                   tt = get_rtime()-t_0; t_g += tt;
                                   t_0 = get_rtime();
                                   divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);
                                   if ( !dp_fcoeffs && DP_NFStat ) {
                                           fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
                                           fflush(asir_out);
                                   }
                                   mulq(cr,dc,&dcq);
                                   mulq(cont,rc,&rcq);
                                   igcd_cofactor(dcq,rcq,&gcd,&dc,&rc);
                                   tt = get_rtime()-t_0; t_a += tt;
                                   rp = t;
                                   hmag = multiple*HMAG(rp)/denom;
                                   if ( GenTrace ) {
                                           ARG3(BDY(hist)) = (pointer)gcd;
                                           MKNODE(node,hist,TraceList); TraceList = node;
                                   }
                           } else {
                                   t_0 = get_rtime();
                                   mulq(cr,dc,&dcq); dc = dcq;
                                   tt = get_rtime()-t_0; t_a += tt;
                                   rp = u;
                                   if ( GenTrace ) {
                                           ARG3(BDY(hist)) = (pointer)ONE;
                                           MKNODE(node,hist,TraceList); TraceList = node;
                                   }
                           }
                   } else if ( !full ) {
                           if ( rp ) {
                                   MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;
                           }
                           *r = rp;
                           goto final;
                   } else {
                           t_0 = get_rtime();
                           mulq((Q)BDY(rp)->c,rc,&c);
                           igcd_cofactor(dc,c,&gcd,&dcq,&cq);
                           muldc(CO,dp,(P)dcq,&t1);
                           m = BDY(rp); NEWMP(mr); mr->dl = m->dl; mr->c = (P)cq;
                           NEXT(mr) = 0; MKDP(rp->nv,mr,t); t->sugar = mr->dl->td;
                           addd(CO,t,t1,&dp);
                           dc = gcd;
   
                           dp_rest(rp,&t); rp = t;
                           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 )
                   dp->sugar = sugar;
           *r = dp;
   final:
           if ( DP_NFStat )
                   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_g,t_a,
                           pz_t_e, pz_t_d, pz_t_d1, pz_t_c);
   }
   
   void imulv();
   
   void dp_imul_d(p,q,rp)
   DP p;
   Q q;
   DP *rp;
   {
           int nsep,ndist,i,j,k,l,n;
           double t0,t1,t2;
           Q *s;
           pointer *b;
           VECT c,cs,ri;
           VECT *r;
           MP m;
           NODE tn,dist,n0,n1,n2;
           Obj dmy;
           STRING imul;
   
           extern LIST Dist;
   
           if ( !p || !q ) {
                   *rp = 0; return;
           }
           dist = BDY(Dist);
           for ( tn = dist, ndist = 0; tn; tn = NEXT(tn), ndist++ );
           nsep = ndist + 1;
           for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );
           if ( n <= nsep ) {
                   muldc(CO,p,(P)q,rp); return;
           }
           MKSTR(imul,"imulv");
           t0 = get_rtime();
           dp_dtov(p,&c);
           sepvect(c,nsep,&cs);
           r = (VECT *)CALLOC(nsep,sizeof(VECT *));
           for ( i = 0, tn = dist, b = BDY(cs); i < ndist; i++, tn = NEXT(tn) ) {
                   n0 = mknode(4,BDY(tn),imul,b[i],q);
                   Pox_rpc(n0,&dmy);
           }
           t1 = get_rtime();
           im_t_s += t1 - t0;
           imulv(b[i],q,&r[i]);
           t1 = get_rtime();
           for ( i = 0, tn = dist; i < ndist; i++, tn = NEXT(tn) ) {
                   MKNODE(n0,BDY(tn),0);
                   Pox_pop_local(n0,&r[i]);
                   if ( OID(r[i]) == O_ERR ) {
                           printexpr(CO,(Obj)r[i]);
                           error("dp_imul_d : aborted");
                   }
           }
           t2 = get_rtime();
           im_t_r += t2 - t1;
           s = (Q *)CALLOC(n,sizeof(Q));
           for ( i = j = 0; i < nsep; i++ ) {
                   for ( k = 0, ri = r[i], l = ri->len; k < l; k++, j++ ) {
                           s[j] = (Q)BDY(ri)[k];
                   }
           }
           dp_vtod(s,p,rp);
   }
   
   void imulv(w,c,rp)
   VECT w;
   Q c;
   VECT *rp;
   {
           int n,i;
           VECT r;
   
           n = w->len;
           MKVECT(r,n); *rp = r;
           for ( i = 0; i < n; i++ )
                   mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);
   }
   
Legend:
Removed from v.1.13  
changed lines
  Added in v.1.14
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>