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

Diff for /OpenXM_contrib2/asir2000/builtin/fctr.c between version 1.11 and 1.18

version 1.11, 2002/01/09 07:45:40 version 1.18, 2003/01/06 01:16:38
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/fctr.c,v 1.10 2001/11/19 00:57:10 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/fctr.c,v 1.17 2003/01/04 09:06:16 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
   
 void Pfctr(), Pgcd(), Pgcdz(), Plcm(), Psqfr(), Pufctrhint();  void Pfctr(), Pgcd(), Pgcdz(), Plcm(), Psqfr(), Pufctrhint();
 void Pptozp(), Pcont();  void Pptozp(), Pcont(), Psfcont();
 void Pafctr(), Pagcd();  void Pafctr(), Pagcd();
 void Pmodsqfr(),Pmodfctr(),Pddd(),Pnewddd(),Pddd_tab();  void Pmodsqfr(),Pmodfctr(),Pddd(),Pnewddd(),Pddd_tab();
 void Psfsqfr(),Psfbfctr(),Psfufctr(),Psfmintdeg();  void Psfsqfr(),Psffctr(),Psfbfctr(),Psfufctr(),Psfmintdeg(),Psfgcd();
 void Pirred_check(), Pnfctr_mod();  void Pirred_check(), Pnfctr_mod();
   void Pbivariate_hensel_special();
   
 void sfmintdeg(VL vl,P fx,int dy,int c,P *fr);  void sfmintdeg(VL vl,P fx,int dy,int c,P *fr);
 void create_bmono(P c,V x,int i,V y,int j,P *mono);  
   
 struct ftab fctr_tab[] = {  struct ftab fctr_tab[] = {
           {"bivariate_hensel_special",Pbivariate_hensel_special,6},
         {"fctr",Pfctr,-2},          {"fctr",Pfctr,-2},
         {"gcd",Pgcd,-3},          {"gcd",Pgcd,-3},
         {"gcdz",Pgcdz,2},          {"gcdz",Pgcdz,2},
Line 69  struct ftab fctr_tab[] = {
Line 70  struct ftab fctr_tab[] = {
         {"ufctrhint",Pufctrhint,2},          {"ufctrhint",Pufctrhint,2},
         {"ptozp",Pptozp,1},          {"ptozp",Pptozp,1},
         {"cont",Pcont,-2},          {"cont",Pcont,-2},
           {"sfcont",Psfcont,-2},
         {"afctr",Pafctr,2},          {"afctr",Pafctr,2},
         {"agcd",Pagcd,3},          {"agcd",Pagcd,3},
         {"modsqfr",Pmodsqfr,2},          {"modsqfr",Pmodsqfr,2},
         {"modfctr",Pmodfctr,2},          {"modfctr",Pmodfctr,2},
         {"sfsqfr",Psfsqfr,1},          {"sfsqfr",Psfsqfr,1},
           {"sffctr",Psffctr,1},
         {"sfufctr",Psfufctr,1},          {"sfufctr",Psfufctr,1},
         {"sfbfctr",Psfbfctr,-4},          {"sfbfctr",Psfbfctr,-4},
         {"sfmintdeg",Psfmintdeg,5},          {"sfmintdeg",Psfmintdeg,5},
           {"sfgcd",Psfgcd,2},
 #if 0  #if 0
         {"ddd",Pddd,2},          {"ddd",Pddd,2},
         {"newddd",Pnewddd,2},          {"newddd",Pnewddd,2},
Line 87  struct ftab fctr_tab[] = {
Line 91  struct ftab fctr_tab[] = {
         {0,0,0},          {0,0,0},
 };  };
   
   /* bivariate_hensel_special(f(x,y):monic in x,g0(x),h0(y),x,y,d) */
   
   void Pbivariate_hensel_special(arg,rp)
   NODE arg;
   LIST *rp;
   {
           DCP dc;
           struct oVN vn[2];
           P f,g0,h0,ak,bk,gk,hk;
           V vx,vy;
           VL nvl;
           Q qk,cbd,bb;
           int d;
           NODE n;
   
           f = (P)ARG0(arg);
           g0 = (P)ARG1(arg);
           h0 = (P)ARG2(arg);
           vx = VR((P)ARG3(arg));
           vy = VR((P)ARG4(arg));
           d = QTOS((Q)ARG5(arg));
           NEWVL(nvl); nvl->v = vx;
           NEWVL(NEXT(nvl)); NEXT(nvl)->v = vy;
           NEXT(NEXT(nvl)) = 0;
           vn[0].v = vy; vn[0].n = 0;
           vn[1].v = 0; vn[1].n = 0;
           cbound(nvl,f,&cbd);
           addq(cbd,cbd,&bb);
           henzq1(g0,h0,bb,&bk,&ak,&qk);
           henmv(nvl,vn,f,g0,h0,ak,bk,(P)ONE,(P)ONE,(P)ONE,(P)ONE,qk,d,&gk,&hk);
           n = mknode(2,gk,hk);
           MKLIST(*rp,n);
   }
   
 void Pfctr(arg,rp)  void Pfctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
Line 259  P *rp;
Line 297  P *rp;
         }          }
 }  }
   
   void Psfcont(arg,rp)
   NODE arg;
   P *rp;
   {
           DCP dc;
           MP mp;
           int m;
           Obj obj;
           P p,p1;
           P *l;
           V v;
   
           obj = (Obj)ARG0(arg);
           if ( !obj || NUM(obj) )
                   *rp = (P)obj;
           else if ( OID(obj) == O_P ) {
                   p = (P)obj;
                   if ( argc(arg) == 2 ) {
                           v = VR((P)ARG1(arg));
                           change_mvar(CO,p,v,&p1);
                           if ( VR(p1) != v ) {
                                   *rp = p1; return;
                           } else
                                   p = p1;
                   }
                   for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ );
                   l = (P *)ALLOCA(m*sizeof(P));
                   for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ )
                           l[m] = COEF(dc);
                   gcdsf(CO,l,m,rp);
           } else if ( OID(obj) == O_DP ) {
                   for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++ );
                   l = (P *)ALLOCA(m*sizeof(P));
                   for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++)
                           l[m] = mp->c;
                   gcdsf(CO,l,m,rp);
           }
   }
   
 void Pptozp(arg,rp)  void Pptozp(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
Line 308  int Divum();
Line 385  int Divum();
   
 UM *resberle();  UM *resberle();
   
   void reduce_sfdc(DCP sfdc, DCP *dc);
   
 void Pmodfctr(arg,rp)  void Pmodfctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;          DCP dc,dcu;
         int mod;          int mod,i,t;
           P p;
           Obj u;
           VL vl;
   
         mod = QTOS((Q)ARG1(arg));          mod = QTOS((Q)ARG1(arg));
         if ( mod < 0 )          if ( mod < 0 )
                 error("modfctr : invalid modulus");                  error("modfctr : invalid modulus");
         modfctrp(ARG0(arg),mod,NEWDDD,&dc);          p = (P)ARG0(arg);
           clctv(CO,p,&vl);
           if ( !NEXT(vl) )
                   modfctrp(ARG0(arg),mod,NEWDDD,&dc);
           else {
                   /* XXX 16384 should be replaced by a macro */
                   for ( i = 0, t = 1; t*mod < 16384; t *= mod, i++ );
                   current_ff = FF_GFS;
                   setmod_sf(mod,i);
                   simp_ff((Obj)p,&u);
                   mfctrsf(CO,(P)u,&dcu);
                   reduce_sfdc(dcu,&dc);
           }
         if ( !dc ) {          if ( !dc ) {
                 NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;                  NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;
         }          }
         dcptolist(dc,rp);          dcptolist(dc,rp);
 }  }
   
   void Psfgcd(arg,rp)
   NODE arg;
   LIST *rp;
   {
           P ps[2];
   
           ps[0] = (P)ARG0(arg);
           ps[1] = (P)ARG1(arg);
           gcdsf(CO,ps,2,rp);
   }
   
   void Psffctr(arg,rp)
   NODE arg;
   LIST *rp;
   {
           DCP dc;
   
           mfctrsf(CO,ARG0(arg),&dc);
           dcptolist(dc,rp);
   }
   
 void Psfsqfr(arg,rp)  void Psfsqfr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;          DCP dc;
   
         sfsqfr(ARG0(arg),&dc);          sqfrsf(CO,ARG0(arg),&dc);
         dcptolist(dc,rp);          dcptolist(dc,rp);
 }  }
   
Line 341  LIST *rp;
Line 456  LIST *rp;
 {  {
         DCP dc;          DCP dc;
   
         fctrsf(ARG0(arg),&dc);          ufctrsf(ARG0(arg),&dc);
         dcptolist(dc,rp);          dcptolist(dc,rp);
 }  }
   
Line 515  VECT *rp;
Line 630  VECT *rp;
         *rp = result;          *rp = result;
 }  }
   
 struct lb {  void reduce_sfdc(DCP sfdc,DCP *dcr)
         int pos,len;  
         int *r;  
         int *hist;  
 };  
   
 static NODE insert_lb(NODE g,struct lb *a)  
 {  {
         NODE prev,cur,n;          P c,t,s,u,f;
           DCP dc0,dc,tdc;
           DCP *a;
           int i,j,n;
   
         prev = 0; cur = g;          if ( !current_gfs_ext ) {
         while ( cur ) {                  /* we simply apply sfptop() */
                 if ( a->pos < ((struct lb *)BDY(cur))->pos ) {                  for ( dc0 = 0; sfdc; sfdc = NEXT(sfdc) ) {
                         MKNODE(n,a,cur);                          NEXTDC(dc0,dc);
                         if ( !prev )                          DEG(dc) = DEG(sfdc);
                                 return n;                          sfptop(COEF(sfdc),&COEF(dc));
                         else {  
                                 NEXT(prev) = n;  
                                 return g;  
                         }  
                 } else {  
                         prev = cur;  
                         cur = NEXT(cur);  
                 }                  }
                   NEXT(dc) = 0;
                   *dcr = dc0;
                   return;
         }          }
         MKNODE(n,a,0);  
         NEXT(prev) = n;  
         return g;  
 }  
   
 static void lnf(int *r,int *h,int n,int len,NODE g)          if ( NUM(COEF(sfdc)) ) {
 {                  sfptop(COEF(sfdc),&c);
         struct lb *t;                  sfdc = NEXT(sfdc);
         int pos,i,j,len1,c;          } else
         int *r1,*h1;                  c = (P)ONE;
   
         for ( ; g; g = NEXT(g) ) {          for ( n = 0, tdc = sfdc; tdc; tdc = NEXT(tdc), n++ );
                 t = (struct lb *)BDY(g);          a = (DCP *)ALLOCA(n*sizeof(DCP));
                 pos = t->pos;          for ( i = 0, tdc = sfdc; i < n; tdc = NEXT(tdc), i++ )
                 if ( c = r[pos] ) {                  a[i] = tdc;
                         r1 = t->r;  
                         h1 = t->hist;  
                         len1 = t->len;  
                         for ( i = pos; i < n; i++ )  
                                 r[i] = _subsf(r[i],_mulsf(r1[i],c));  
                         for ( i = 0; i < len1; i++ )  
                                 h[i] = _subsf(h[i],_mulsf(h1[i],c));  
                 }  
         }  
         for ( i = 0; i < n && !r[i]; i++ );  
         if ( i < n ) {  
                 c = _invsf(r[i]);  
                 for ( j = i; j < n; j++ )  
                         r[j] = _mulsf(r[j],c);  
                 for ( j = i; j < len; j++ )  
                         h[j] = _mulsf(h[j],c);  
         }  
 }  
   
 void print_vect(int *r,int len)          dc0 = 0; NEXTDC(dc0,dc); DEG(dc) = ONE; COEF(dc) = c;
 {          for ( i = 0; i < n; i++ ) {
         int i;                  if ( !a[i] )
                           continue;
         for ( i = 0; i < len; i++ )                  t = COEF(a[i]);
                 if ( r[i] ) printf("(%d %d)",i,IFTOF(r[i]));                  f = t;
         printf("\n");                  while ( 1 ) {
 }                          sf_galois_action(t,ONE,&s);
                           for ( j = i; j < n; j++ )
 void sfmintdeg(VL vl,P fx,int dy,int c,P *fr)                                  if ( a[j] && !compp(CO,s,COEF(a[j])) )
 {                                          break;
         V x,y;                          if ( j == n )
         int dx,dxdy,i,j,k,l,d,len,len0,u,dyk;                                  error("reduce_sfdc : cannot happen");
         UP *rx;                          if ( j == i ) {
         DCP dc;                                  NEXTDC(dc0,dc); DEG(dc) = DEG(a[i]);
         P t,f,mono,f1;                                  sfptop(f,&COEF(dc));
         UP ut,h;                                  break;
         int ***nf;  
         int *r,*hist,*prev,*r1;  
         struct lb *lb;  
         GFS s;  
         NODE g;  
   
         x = vl->v;  
         y = NEXT(vl)->v;  
         dx = getdeg(x,fx);  
         dxdy = dx*dy;  
         /* rx = -(fx-x^dx) */  
         rx = (UP *)CALLOC(dx,sizeof(UP));  
         for ( dc = DC(fx); dc; dc = NEXT(dc)) {  
                 chsgnp(COEF(dc),&t);  
                 ptoup(t,&ut);  
                 rx[QTOS(DEG(dc))] = ut;  
         }  
         /* nf[d] = normal form table of monomials with total degree d */  
         nf = (int ***)CALLOC(dx+dy+1,sizeof(int **)); /* xxx */  
         nf[0] = (int **)CALLOC(1,sizeof(int *));  
   
         /* nf[0][0] = 1 */  
         r = (int *)CALLOC(dxdy,sizeof(int));  
         r[0] = _onesf();  
         nf[0][0] = r;  
   
         hist = (int *)CALLOC(1,sizeof(int));  
         r[0] = _onesf();  
   
         lb = (struct lb *)CALLOC(1,sizeof(struct lb));  
         lb->pos = 0;  
         lb->r = r;  
         lb->hist = hist;  
         lb->len = 1;  
   
         /* g : table of normal form as linear form */  
         MKNODE(g,lb,0);  
   
         len = 1;  
         h = UPALLOC(dy);  
         for ( d = 1; ; d++ ) {  
                 if ( d > c ){  
                         return;  
                 }  
                 nf[d] = (int **)CALLOC(d+1,sizeof(int *));  
                 len0 = len;  
                 len += d+1;  
   
                 for ( i = d; i >= 0; i-- ) {  
                         /* nf(x^(d-i)*y^i) = nf(y*nf(x^(d-i)*y^(i-1))) */  
                         /* nf(x^d) = nf(nf(x^(d-1))*x) */  
                         r = (int *)CALLOC(dxdy,sizeof(int));  
                         if ( i == 0 ) {  
                                 prev = nf[d-1][0];  
                                 bcopy(prev,r+dy,(dxdy-dy)*sizeof(int));  
   
                                 /* create the head coeff */  
                                 for ( l = 0, k = dxdy-dy; l < dy; l++, k++ ) {  
                                         if ( prev[k] ) {  
                                                 u = IFTOF(prev[k]);  
                                                 MKGFS(u,s);  
                                         } else  
                                                 s = 0;  
                                         COEF(h)[l] = (Num)s;  
                                 }  
                                 for ( l = dy-1; l >= 0 && !COEF(h)[l]; l--);  
                                 DEG(h) = l;  
   
                                 for ( k = 0, dyk = 0; k < dx; k++, dyk += dy ) {  
                                         tmulup(rx[k],h,dy,&ut);  
                                         if ( ut )  
                                                 for ( l = 0; l < dy; l++ ) {  
                                                         s = (GFS)COEF(ut)[l];  
                                                         if ( s ) {  
                                                                 u = CONT(s);  
                                                                 r[dyk+l] = _addsf(r[dyk+l],FTOIF(u));  
                                                         }  
                                                 }  
                                 }  
                         } else {                          } else {
                                 prev = nf[d-1][i-1];                                  mulp(CO,f,s,&u); f = u;
                                 for ( k = 0, dyk = 0; k < dx; k++, dyk += dy ) {                                  t = s;
                                         for ( l = 1; l < dy; l++ )                                  a[j] = 0;
                                                 r[dyk+l] = prev[dyk+l-1];  
                                 }  
                         }                          }
                         nf[d][i] = r;  
                         hist = (int *)CALLOC(len,sizeof(int));  
                         hist[len0+i] = _onesf();  
                         r1 = (int *)CALLOC(dxdy,sizeof(int));  
                         bcopy(r,r1,dxdy*sizeof(int));  
                         lnf(r1,hist,dxdy,len,g);  
                         for ( k = 0; k < dxdy && !r1[k]; k++ );  
                         if ( k == dxdy ) {  
                                 f = 0;  
                                 for ( k = j = 0; k <= d; k++ )  
                                         for ( i = 0; i <= k; i++, j++ )  
                                                 if ( hist[j] ) {  
                                                         u = IFTOF(hist[j]);  
                                                         MKGFS(u,s);  
                                                         /* mono = s*x^(k-i)*y^i */  
                                                         create_bmono((P)s,x,k-i,y,i,&mono);  
                                                         addp(vl,f,mono,&f1);  
                                                         f = f1;  
                                                 }  
                                 *fr = f;  
                                 return;  
                         }       else {  
                                 lb = (struct lb *)CALLOC(1,sizeof(struct lb));  
                                 lb->pos = k;  
                                 lb->r = r1;  
                                 lb->hist = hist;  
                                 lb->len = len;  
                                 g = insert_lb(g,lb);  
                         }  
                 }                  }
         }          }
 }          *dcr = dc0;
   
 void create_bmono(P c,V x,int i,V y,int j,P *mono)  
 {  
         P t,s;  
   
         if ( !i )  
                 if ( !j )  
                         t = c;  
                 else {  
                         /* c*y^j */  
                         MKV(y,t);  
                         COEF(DC(t)) = c;  
                         STOQ(j,DEG(DC(t)));  
                 }  
         else if ( !j ) {  
                 /* c*x^i */  
                 MKV(x,t);  
                 COEF(DC(t)) = c;  
                 STOQ(i,DEG(DC(t)));  
         } else {  
                 MKV(y,s);  
                 COEF(DC(s)) = c;  
                 STOQ(j,DEG(DC(s)));  
                 MKV(x,t);  
                 COEF(DC(t)) = s;  
                 STOQ(i,DEG(DC(t)));  
         }  
         *mono = t;  
 }  }
Legend:
Removed from v.1.11  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>