[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.14 and 1.24

version 1.14, 2002/09/30 06:15:51 version 1.24, 2017/02/27 05:14:54
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.13 2002/09/27 08:40:48 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/fctr.c,v 1.23 2004/07/30 07:34:40 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(),Psfgcd();  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);
   
 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 68  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},
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 Pptozp(arg,rp)  void Psfcont(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  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)
   NODE arg;
   Obj *rp;
   {
         Q t;          Q t;
       NODE tt,p;
       NODE n,n0;
       char *key;
           P pp;
           LIST list;
       int get_factor=0;
   
         asir_assert(ARG0(arg),O_P,"ptozp");          asir_assert(ARG0(arg),O_P,"ptozp");
         ptozp((P)ARG0(arg),1,&t,rp);  
       /* analyze the option */
       if ( current_option ) {
         for ( tt = current_option; tt; tt = NEXT(tt) ) {
           p = BDY((LIST)BDY(tt));
           key = BDY((STRING)BDY(p));
           /*  value = (Obj)BDY(NEXT(p)); */
           if ( !strcmp(key,"factor") )  get_factor=1;
           else {
             error("ptozp: unknown option.");
           }
         }
       }
   
           ptozp((P)ARG0(arg),1,&t,&pp);
   
       /* printexpr(NULL,t); */
           /* if the option factor is given, then it returns the answer
          in the format [zpoly, num] where num*zpoly is equal to the argument.*/
       if (get_factor) {
             n0 = mknode(2,pp,t);
         MKLIST(list,n0);
             *rp = (Obj)list;
       } else
         *rp = (Obj)pp;
 }  }
   
 void Pafctr(arg,rp)  void Pafctr(arg,rp)
Line 308  int Divum();
Line 415  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 ( !vl ) {
                   NEWDC(dc); COEF(dc) = p; DEG(dc) = ONE; NEXT(dc) = 0;
           } else if ( !NEXT(vl) )
                   modfctrp(ARG0(arg),mod,NEWDDD,&dc);
           else {
                   /* XXX 16384 should be replaced by a macro */
                   for ( i = 1, t = mod; 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;
         }          }
Line 336  LIST *rp;
Line 462  LIST *rp;
         gcdsf(CO,ps,2,rp);          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;
Line 352  LIST *rp;
Line 488  LIST *rp;
 {  {
         DCP dc;          DCP dc;
   
         fctrsf(ARG0(arg),&dc);          ufctrsf(ARG0(arg),&dc);
         dcptolist(dc,rp);          dcptolist(dc,rp);
 }  }
   
Line 524  VECT *rp;
Line 660  VECT *rp;
         for ( i = 0; i < n; i++ )          for ( i = 0; i < n; i++ )
                 umtop(v,r[i],(P *)&BDY(result)[i]);                  umtop(v,r[i],(P *)&BDY(result)[i]);
         *rp = result;          *rp = result;
   }
   
   void reduce_sfdc(DCP sfdc,DCP *dcr)
   {
           P c,t,s,u,f;
           DCP dc0,dc,tdc;
           DCP *a;
           int i,j,n;
   
           if ( !current_gfs_ext ) {
                   /* we simply apply sfptop() */
                   for ( dc0 = 0; sfdc; sfdc = NEXT(sfdc) ) {
                           NEXTDC(dc0,dc);
                           DEG(dc) = DEG(sfdc);
                           sfptop(COEF(sfdc),&COEF(dc));
                   }
                   NEXT(dc) = 0;
                   *dcr = dc0;
                   return;
           }
   
           if ( NUM(COEF(sfdc)) ) {
                   sfptop(COEF(sfdc),&c);
                   sfdc = NEXT(sfdc);
           } else
                   c = (P)ONE;
   
           for ( n = 0, tdc = sfdc; tdc; tdc = NEXT(tdc), n++ );
           a = (DCP *)ALLOCA(n*sizeof(DCP));
           for ( i = 0, tdc = sfdc; i < n; tdc = NEXT(tdc), i++ )
                   a[i] = tdc;
   
           dc0 = 0; NEXTDC(dc0,dc); DEG(dc) = ONE; COEF(dc) = c;
           for ( i = 0; i < n; i++ ) {
                   if ( !a[i] )
                           continue;
                   t = COEF(a[i]);
                   f = t;
                   while ( 1 ) {
                           sf_galois_action(t,ONE,&s);
                           for ( j = i; j < n; j++ )
                                   if ( a[j] && !compp(CO,s,COEF(a[j])) )
                                           break;
                           if ( j == n )
                                   error("reduce_sfdc : cannot happen");
                           if ( j == i ) {
                                   NEXTDC(dc0,dc); DEG(dc) = DEG(a[i]);
                                   sfptop(f,&COEF(dc));
                                   break;
                           } else {
                                   mulp(CO,f,s,&u); f = u;
                                   t = s;
                                   a[j] = 0;
                           }
                   }
           }
           *dcr = dc0;
 }  }
Legend:
Removed from v.1.14  
changed lines
  Added in v.1.24
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>