[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.24 and 1.25

version 1.24, 2017/02/27 05:14:54 version 1.25, 2018/03/29 01:32:50
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.23 2004/07/30 07:34:40 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/fctr.c,v 1.24 2017/02/27 05:14:54 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 61  void Pbivariate_hensel_special();
Line 61  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},    {"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},
         {"lcm",Plcm,2},    {"lcm",Plcm,2},
         {"sqfr",Psqfr,1},    {"sqfr",Psqfr,1},
         {"ufctrhint",Pufctrhint,2},    {"ufctrhint",Pufctrhint,2},
         {"ptozp",Pptozp,1},    {"ptozp",Pptozp,1},
         {"cont",Pcont,-2},    {"cont",Pcont,-2},
         {"sfcont",Psfcont,-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},    {"sffctr",Psffctr,1},
         {"sfufctr",Psfufctr,1},    {"sfufctr",Psfufctr,1},
         {"sfbfctr",Psfbfctr,-4},    {"sfbfctr",Psfbfctr,-4},
         {"sfmintdeg",Psfmintdeg,5},    {"sfmintdeg",Psfmintdeg,5},
         {"sfgcd",Psfgcd,2},    {"sfgcd",Psfgcd,2},
 #if 0  #if 0
         {"ddd",Pddd,2},    {"ddd",Pddd,2},
         {"newddd",Pnewddd,2},    {"newddd",Pnewddd,2},
 #endif  #endif
         {"ddd_tab",Pddd_tab,2},    {"ddd_tab",Pddd_tab,2},
         {"irred_check",Pirred_check,2},    {"irred_check",Pirred_check,2},
         {"nfctr_mod",Pnfctr_mod,2},    {"nfctr_mod",Pnfctr_mod,2},
         {0,0,0},    {0,0,0},
 };  };
   
 /* bivariate_hensel_special(f(x,y):monic in x,g0(x),h0(y),x,y,d) */  /* bivariate_hensel_special(f(x,y):monic in x,g0(x),h0(y),x,y,d) */
Line 97  void Pbivariate_hensel_special(arg,rp)
Line 97  void Pbivariate_hensel_special(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
         struct oVN vn[2];    struct oVN vn[2];
         P f,g0,h0,ak,bk,gk,hk;    P f,g0,h0,ak,bk,gk,hk;
         V vx,vy;    V vx,vy;
         VL nvl;    VL nvl;
         Q qk,cbd,bb;    Q qk,cbd,bb;
         int d;    int d;
         NODE n;    NODE n;
   
         f = (P)ARG0(arg);    f = (P)ARG0(arg);
         g0 = (P)ARG1(arg);    g0 = (P)ARG1(arg);
         h0 = (P)ARG2(arg);    h0 = (P)ARG2(arg);
         vx = VR((P)ARG3(arg));    vx = VR((P)ARG3(arg));
         vy = VR((P)ARG4(arg));    vy = VR((P)ARG4(arg));
         d = QTOS((Q)ARG5(arg));    d = QTOS((Q)ARG5(arg));
         NEWVL(nvl); nvl->v = vx;    NEWVL(nvl); nvl->v = vx;
         NEWVL(NEXT(nvl)); NEXT(nvl)->v = vy;    NEWVL(NEXT(nvl)); NEXT(nvl)->v = vy;
         NEXT(NEXT(nvl)) = 0;    NEXT(NEXT(nvl)) = 0;
         vn[0].v = vy; vn[0].n = 0;    vn[0].v = vy; vn[0].n = 0;
         vn[1].v = 0; vn[1].n = 0;    vn[1].v = 0; vn[1].n = 0;
         cbound(nvl,f,&cbd);    cbound(nvl,f,&cbd);
         addq(cbd,cbd,&bb);    addq(cbd,cbd,&bb);
         henzq1(g0,h0,bb,&bk,&ak,&qk);    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);    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);    n = mknode(2,gk,hk);
         MKLIST(*rp,n);    MKLIST(*rp,n);
 }  }
   
 void Pfctr(arg,rp)  void Pfctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         asir_assert(ARG0(arg),O_P,"fctr");    asir_assert(ARG0(arg),O_P,"fctr");
         if ( argc(arg) == 1 )    if ( argc(arg) == 1 )
                 fctrp(CO,(P)ARG0(arg),&dc);      fctrp(CO,(P)ARG0(arg),&dc);
         else {    else {
                 asir_assert(ARG1(arg),O_P,"fctr");      asir_assert(ARG1(arg),O_P,"fctr");
                 fctr_wrt_v_p(CO,(P)ARG0(arg),VR((P)ARG1(arg)),&dc);      fctr_wrt_v_p(CO,(P)ARG0(arg),VR((P)ARG1(arg)),&dc);
         }    }
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pgcd(arg,rp)  void Pgcd(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         P p1,p2,g1,g2,g;    P p1,p2,g1,g2,g;
         Num m;    Num m;
         int mod;    int mod;
   
         p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);    p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);
         asir_assert(p1,O_P,"gcd");    asir_assert(p1,O_P,"gcd");
         asir_assert(p2,O_P,"gcd");    asir_assert(p2,O_P,"gcd");
         if ( !p1 )    if ( !p1 )
                 *rp = p2;      *rp = p2;
         else if ( !p2 )    else if ( !p2 )
                 *rp = p1;      *rp = p1;
         else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )    else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )
                 gcdprsp(CO,p1,p2,rp);      gcdprsp(CO,p1,p2,rp);
         else if ( argc(arg) == 2 )    else if ( argc(arg) == 2 )
                 ezgcdp(CO,p1,p2,rp);      ezgcdp(CO,p1,p2,rp);
         else {    else {
                 m = (Num)ARG2(arg);      m = (Num)ARG2(arg);
                 asir_assert(m,O_P,"gcd");      asir_assert(m,O_P,"gcd");
                 mod = QTOS((Q)m);      mod = QTOS((Q)m);
                 ptomp(mod,p1,&g1); ptomp(mod,p2,&g2);      ptomp(mod,p1,&g1); ptomp(mod,p2,&g2);
                 gcdprsmp(CO,mod,g1,g2,&g);      gcdprsmp(CO,mod,g1,g2,&g);
                 mptop(g,rp);      mptop(g,rp);
         }    }
 }  }
   
 void Pgcdz(arg,rp)  void Pgcdz(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         P p1,p2,t;    P p1,p2,t;
         Q c1,c2;    Q c1,c2;
         N n;    N n;
   
         p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);    p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);
         asir_assert(p1,O_P,"gcdz");    asir_assert(p1,O_P,"gcdz");
         asir_assert(p2,O_P,"gcdz");    asir_assert(p2,O_P,"gcdz");
         if ( !p1 )    if ( !p1 )
                 *rp = p2;      *rp = p2;
         else if ( !p2 )    else if ( !p2 )
                 *rp = p1;      *rp = p1;
         else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )    else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )
                 error("gcdz : invalid argument");      error("gcdz : invalid argument");
         else if ( NUM(p1) || NUM(p2) ) {    else if ( NUM(p1) || NUM(p2) ) {
                 if ( NUM(p1) )      if ( NUM(p1) )
                         c1 = (Q)p1;        c1 = (Q)p1;
                 else      else
                         ptozp(p1,1,&c1,&t);        ptozp(p1,1,&c1,&t);
                 if ( NUM(p2) )      if ( NUM(p2) )
                         c2 = (Q)p2;        c2 = (Q)p2;
                 else      else
                         ptozp(p2,1,&c2,&t);        ptozp(p2,1,&c2,&t);
                 gcdn(NM(c1),NM(c2),&n); NTOQ(n,1,c1); *rp = (P)c1;      gcdn(NM(c1),NM(c2),&n); NTOQ(n,1,c1); *rp = (P)c1;
         } else {    } else {
 #if 0  #if 0
                 w[0] = p1; w[1] = p2; nezgcdnpz(CO,w,2,rp);      w[0] = p1; w[1] = p2; nezgcdnpz(CO,w,2,rp);
 #endif  #endif
                 ezgcdpz(CO,p1,p2,rp);      ezgcdpz(CO,p1,p2,rp);
         }    }
 }  }
   
 void Plcm(arg,rp)  void Plcm(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         P t1,t2,p1,p2,g,q;    P t1,t2,p1,p2,g,q;
         Q c;    Q c;
   
         p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);    p1 = (P)ARG0(arg); p2 = (P)ARG1(arg);
         asir_assert(p1,O_P,"lcm");    asir_assert(p1,O_P,"lcm");
         asir_assert(p2,O_P,"lcm");    asir_assert(p2,O_P,"lcm");
         if ( !p1 || !p2 )    if ( !p1 || !p2 )
                 *rp = 0;      *rp = 0;
         else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )    else if ( !qpcheck((Obj)p1) || !qpcheck((Obj)p2) )
                 error("lcm : invalid argument");      error("lcm : invalid argument");
         else {    else {
                 ptozp(p1,1,&c,&t1); ptozp(p2,1,&c,&t2);      ptozp(p1,1,&c,&t1); ptozp(p2,1,&c,&t2);
                 ezgcdp(CO,t1,t2,&g); divsp(CO,t1,g,&q); mulp(CO,q,t2,rp);      ezgcdp(CO,t1,t2,&g); divsp(CO,t1,g,&q); mulp(CO,q,t2,rp);
         }    }
 }  }
   
 void Psqfr(arg,rp)  void Psqfr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         asir_assert(ARG0(arg),O_P,"sqfr");    asir_assert(ARG0(arg),O_P,"sqfr");
         sqfrp(CO,(P)ARG0(arg),&dc);    sqfrp(CO,(P)ARG0(arg),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pufctrhint(arg,rp)  void Pufctrhint(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         asir_assert(ARG0(arg),O_P,"ufctrhint");    asir_assert(ARG0(arg),O_P,"ufctrhint");
         asir_assert(ARG1(arg),O_N,"ufctrhint");    asir_assert(ARG1(arg),O_N,"ufctrhint");
         ufctr((P)ARG0(arg),QTOS((Q)ARG1(arg)),&dc);    ufctr((P)ARG0(arg),QTOS((Q)ARG1(arg)),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 #if 0  #if 0
Line 253  Pmgcd(arg,rp)
Line 253  Pmgcd(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  Obj *rp;
 {  {
         NODE node,tn;    NODE node,tn;
         int i,m;    int i,m;
         P *l;    P *l;
   
         node = BDY((LIST)ARG0(arg));    node = BDY((LIST)ARG0(arg));
         for ( i = 0, tn = node; tn; tn = NEXT(tn), i++ );    for ( i = 0, tn = node; tn; tn = NEXT(tn), i++ );
         m = i; l = (P *)ALLOCA(m*sizeof(P));    m = i; l = (P *)ALLOCA(m*sizeof(P));
         for ( i = 0, tn = node; i < m; tn = NEXT(tn), i++ )    for ( i = 0, tn = node; i < m; tn = NEXT(tn), i++ )
                 l[i] = (P)BDY(tn);      l[i] = (P)BDY(tn);
         nezgcdnpz(CO,l,m,rp);    nezgcdnpz(CO,l,m,rp);
 }  }
 #endif  #endif
   
Line 270  void Pcont(arg,rp)
Line 270  void Pcont(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         DCP dc;    DCP dc;
         int m;    int m;
         P p,p1;    P p,p1;
         P *l;    P *l;
         V v;    V v;
   
         asir_assert(ARG0(arg),O_P,"cont");    asir_assert(ARG0(arg),O_P,"cont");
         p = (P)ARG0(arg);    p = (P)ARG0(arg);
         if ( NUM(p) )    if ( NUM(p) )
                 *rp = p;      *rp = p;
         else {    else {
                 if ( argc(arg) == 2 ) {      if ( argc(arg) == 2 ) {
                         v = VR((P)ARG1(arg));        v = VR((P)ARG1(arg));
                         change_mvar(CO,p,v,&p1);        change_mvar(CO,p,v,&p1);
                         if ( VR(p1) != v ) {        if ( VR(p1) != v ) {
                                 *rp = p1; return;          *rp = p1; return;
                         } else        } else
                                 p = p1;          p = p1;
                 }      }
                 for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ );      for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ );
                 l = (P *)ALLOCA(m*sizeof(P));      l = (P *)ALLOCA(m*sizeof(P));
                 for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ )      for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ )
                         l[m] = COEF(dc);        l[m] = COEF(dc);
                 nezgcdnpz(CO,l,m,rp);      nezgcdnpz(CO,l,m,rp);
         }    }
 }  }
   
 void Psfcont(arg,rp)  void Psfcont(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         DCP dc;    DCP dc;
         MP mp;    MP mp;
         int m;    int m;
         Obj obj;    Obj obj;
         P p,p1;    P p,p1;
         P *l;    P *l;
         V v;    V v;
   
         obj = (Obj)ARG0(arg);    obj = (Obj)ARG0(arg);
         if ( !obj || NUM(obj) )    if ( !obj || NUM(obj) )
                 *rp = (P)obj;      *rp = (P)obj;
         else if ( OID(obj) == O_P ) {    else if ( OID(obj) == O_P ) {
                 p = (P)obj;      p = (P)obj;
                 if ( argc(arg) == 2 ) {      if ( argc(arg) == 2 ) {
                         v = VR((P)ARG1(arg));        v = VR((P)ARG1(arg));
                         change_mvar(CO,p,v,&p1);        change_mvar(CO,p,v,&p1);
                         if ( VR(p1) != v ) {        if ( VR(p1) != v ) {
                                 *rp = p1; return;          *rp = p1; return;
                         } else        } else
                                 p = p1;          p = p1;
                 }      }
                 for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ );      for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ );
                 l = (P *)ALLOCA(m*sizeof(P));      l = (P *)ALLOCA(m*sizeof(P));
                 for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ )      for ( m = 0, dc = DC(p); dc; dc = NEXT(dc), m++ )
                         l[m] = COEF(dc);        l[m] = COEF(dc);
                 gcdsf(CO,l,m,rp);      gcdsf(CO,l,m,rp);
         } else if ( OID(obj) == O_DP ) {    } else if ( OID(obj) == O_DP ) {
                 for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++ );      for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++ );
                 l = (P *)ALLOCA(m*sizeof(P));      l = (P *)ALLOCA(m*sizeof(P));
                 for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++)      for ( m = 0, mp = BDY((DP)obj); mp; mp = NEXT(mp), m++)
                         l[m] = mp->c;        l[m] = mp->c;
                 gcdsf(CO,l,m,rp);      gcdsf(CO,l,m,rp);
         }    }
 }  }
   
 void Pptozp(arg,rp)  void Pptozp(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  Obj *rp;
 {  {
         Q t;    Q t;
     NODE tt,p;      NODE tt,p;
     NODE n,n0;      NODE n,n0;
     char *key;      char *key;
         P pp;    P pp;
         LIST list;    LIST list;
     int get_factor=0;      int get_factor=0;
   
         asir_assert(ARG0(arg),O_P,"ptozp");    asir_assert(ARG0(arg),O_P,"ptozp");
   
     /* analyze the option */      /* analyze the option */
     if ( current_option ) {      if ( current_option ) {
Line 363  Obj *rp;
Line 363  Obj *rp;
       }        }
     }      }
   
         ptozp((P)ARG0(arg),1,&t,&pp);    ptozp((P)ARG0(arg),1,&t,&pp);
   
     /* printexpr(NULL,t); */      /* printexpr(NULL,t); */
         /* if the option factor is given, then it returns the answer    /* if the option factor is given, then it returns the answer
        in the format [zpoly, num] where num*zpoly is equal to the argument.*/         in the format [zpoly, num] where num*zpoly is equal to the argument.*/
     if (get_factor) {      if (get_factor) {
           n0 = mknode(2,pp,t);      n0 = mknode(2,pp,t);
       MKLIST(list,n0);        MKLIST(list,n0);
           *rp = (Obj)list;      *rp = (Obj)list;
     } else      } else
       *rp = (Obj)pp;        *rp = (Obj)pp;
 }  }
Line 380  void Pafctr(arg,rp)
Line 380  void Pafctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         asir_assert(ARG0(arg),O_P,"afctr");    asir_assert(ARG0(arg),O_P,"afctr");
         asir_assert(ARG1(arg),O_P,"afctr");    asir_assert(ARG1(arg),O_P,"afctr");
         afctr(CO,(P)ARG0(arg),(P)ARG1(arg),&dc);    afctr(CO,(P)ARG0(arg),(P)ARG1(arg),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pagcd(arg,rp)  void Pagcd(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         asir_assert(ARG0(arg),O_P,"agcd");    asir_assert(ARG0(arg),O_P,"agcd");
         asir_assert(ARG1(arg),O_P,"agcd");    asir_assert(ARG1(arg),O_P,"agcd");
         asir_assert(ARG2(arg),O_P,"agcd");    asir_assert(ARG2(arg),O_P,"agcd");
         gcda(CO,(P)ARG0(arg),(P)ARG1(arg),(P)ARG2(arg),rp);    gcda(CO,(P)ARG0(arg),(P)ARG1(arg),(P)ARG2(arg),rp);
 }  }
   
 #if 1  #if 1
Line 421  void Pmodfctr(arg,rp)
Line 421  void Pmodfctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc,dcu;    DCP dc,dcu;
         int mod,i,t;    int mod,i,t;
         P p;    P p;
         Obj u;    Obj u;
         VL vl;    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");
         p = (P)ARG0(arg);    p = (P)ARG0(arg);
         clctv(CO,p,&vl);    clctv(CO,p,&vl);
         if ( !vl ) {    if ( !vl ) {
                 NEWDC(dc); COEF(dc) = p; DEG(dc) = ONE; NEXT(dc) = 0;      NEWDC(dc); COEF(dc) = p; DEG(dc) = ONE; NEXT(dc) = 0;
         } else if ( !NEXT(vl) )    } else if ( !NEXT(vl) )
                 modfctrp(ARG0(arg),mod,NEWDDD,&dc);      modfctrp(ARG0(arg),mod,NEWDDD,&dc);
         else {    else {
                 /* XXX 16384 should be replaced by a macro */      /* XXX 16384 should be replaced by a macro */
                 for ( i = 1, t = mod; t*mod < 16384; t *= mod, i++ );      for ( i = 1, t = mod; t*mod < 16384; t *= mod, i++ );
                 current_ff = FF_GFS;      current_ff = FF_GFS;
                 setmod_sf(mod,i);      setmod_sf(mod,i);
                 simp_ff((Obj)p,&u);      simp_ff((Obj)p,&u);
                 mfctrsf(CO,(P)u,&dcu);      mfctrsf(CO,(P)u,&dcu);
                 reduce_sfdc(dcu,&dc);      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)  void Psfgcd(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         P ps[2];    P ps[2];
   
         ps[0] = (P)ARG0(arg);    ps[0] = (P)ARG0(arg);
         ps[1] = (P)ARG1(arg);    ps[1] = (P)ARG1(arg);
         gcdsf(CO,ps,2,rp);    gcdsf(CO,ps,2,rp);
 }  }
   
 void Psffctr(arg,rp)  void Psffctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         mfctrsf(CO,ARG0(arg),&dc);    mfctrsf(CO,ARG0(arg),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Psfsqfr(arg,rp)  void Psfsqfr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         sqfrsf(CO,ARG0(arg),&dc);    sqfrsf(CO,ARG0(arg),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Psfufctr(arg,rp)  void Psfufctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         ufctrsf(ARG0(arg),&dc);    ufctrsf(ARG0(arg),&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Psfbfctr(arg,rp)  void Psfbfctr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         V x,y;    V x,y;
         DCP dc,dct;    DCP dc,dct;
         P t;    P t;
         struct oVL vl1,vl2;    struct oVL vl1,vl2;
         VL vl;    VL vl;
         int degbound;    int degbound;
   
         x = VR((P)ARG1(arg));    x = VR((P)ARG1(arg));
         y = VR((P)ARG2(arg));    y = VR((P)ARG2(arg));
         vl1.v = x; vl1.next = &vl2;    vl1.v = x; vl1.next = &vl2;
         vl2.v = y; vl2.next = 0;    vl2.v = y; vl2.next = 0;
         vl = &vl1;    vl = &vl1;
         if ( argc(arg) == 4 )    if ( argc(arg) == 4 )
                 degbound = QTOS((Q)ARG3(arg));      degbound = QTOS((Q)ARG3(arg));
         else    else
                 degbound = -1;      degbound = -1;
   
         sfbfctr((P)ARG0(arg),x,y,degbound,&dc);    sfbfctr((P)ARG0(arg),x,y,degbound,&dc);
         for ( dct = dc; dct; dct = NEXT(dct) ) {    for ( dct = dc; dct; dct = NEXT(dct) ) {
                 reorderp(CO,vl,COEF(dct),&t); COEF(dct) = t;      reorderp(CO,vl,COEF(dct),&t); COEF(dct) = t;
         }    }
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Psfmintdeg(arg,rp)  void Psfmintdeg(arg,rp)
 NODE arg;  NODE arg;
 P *rp;  P *rp;
 {  {
         V x,y;    V x,y;
         P r;    P r;
         struct oVL vl1,vl2;    struct oVL vl1,vl2;
         VL vl;    VL vl;
         int dy,c;    int dy,c;
   
         x = VR((P)ARG1(arg));    x = VR((P)ARG1(arg));
         y = VR((P)ARG2(arg));    y = VR((P)ARG2(arg));
         vl1.v = x; vl1.next = &vl2;    vl1.v = x; vl1.next = &vl2;
         vl2.v = y; vl2.next = 0;    vl2.v = y; vl2.next = 0;
         vl = &vl1;    vl = &vl1;
         dy = QTOS((Q)ARG3(arg));    dy = QTOS((Q)ARG3(arg));
         c = QTOS((Q)ARG4(arg));    c = QTOS((Q)ARG4(arg));
         sfmintdeg(vl,(P)ARG0(arg),dy,c,&r);    sfmintdeg(vl,(P)ARG0(arg),dy,c,&r);
         reorderp(CO,vl,r,rp);    reorderp(CO,vl,r,rp);
 }  }
   
 void Pmodsqfr(arg,rp)  void Pmodsqfr(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         if ( !ARG0(arg) ) {    if ( !ARG0(arg) ) {
                 NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;      NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;
         } else    } else
                 modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),SQFR,&dc);      modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),SQFR,&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pddd(arg,rp)  void Pddd(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc;    DCP dc;
   
         if ( !ARG0(arg) ) {    if ( !ARG0(arg) ) {
                 NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;      NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;
         } else    } else
                 modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),DDD,&dc);      modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),DDD,&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pnewddd(arg,rp)  void Pnewddd(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         DCP dc=0;    DCP dc=0;
   
         if ( !ARG0(arg) ) {    if ( !ARG0(arg) ) {
                 NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;      NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;
         } else    } else
                 modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),NEWDDD,&dc);      modfctrp(ARG0(arg),QTOS((Q)ARG1(arg)),NEWDDD,&dc);
         dcptolist(dc,rp);    dcptolist(dc,rp);
 }  }
   
 void Pirred_check(arg,rp)  void Pirred_check(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
 {  {
         P p;    P p;
         UM mp;    UM mp;
         int r,mod;    int r,mod;
   
         p = (P)ARG0(arg);    p = (P)ARG0(arg);
         if ( !p ) {    if ( !p ) {
                 *rp = 0; return;      *rp = 0; return;
         }    }
         mp = W_UMALLOC(UDEG(p));    mp = W_UMALLOC(UDEG(p));
         mod = QTOS((Q)ARG1(arg));    mod = QTOS((Q)ARG1(arg));
         ptoum(mod,p,mp);    ptoum(mod,p,mp);
         r = irred_check(mp,mod);    r = irred_check(mp,mod);
         if ( r )    if ( r )
                 *rp = ONE;      *rp = ONE;
         else    else
                 *rp = 0;      *rp = 0;
 }  }
   
 void Pnfctr_mod(arg,rp)  void Pnfctr_mod(arg,rp)
 NODE arg;  NODE arg;
 Q *rp;  Q *rp;
 {  {
         P p;    P p;
         UM mp;    UM mp;
         int r,mod;    int r,mod;
   
         p = (P)ARG0(arg);    p = (P)ARG0(arg);
         if ( !p ) {    if ( !p ) {
                 *rp = 0; return;      *rp = 0; return;
         }    }
         mp = W_UMALLOC(UDEG(p));    mp = W_UMALLOC(UDEG(p));
         mod = QTOS((Q)ARG1(arg));    mod = QTOS((Q)ARG1(arg));
         ptoum(mod,p,mp);    ptoum(mod,p,mp);
         r = nfctr_mod(mp,mod);    r = nfctr_mod(mp,mod);
         STOQ(r,*rp);    STOQ(r,*rp);
 }  }
   
 void Pddd_tab(arg,rp)  void Pddd_tab(arg,rp)
 NODE arg;  NODE arg;
 VECT *rp;  VECT *rp;
 {  {
         P p;    P p;
         UM mp,t,q,r1,w,w1;    UM mp,t,q,r1,w,w1;
         UM *r,*s;    UM *r,*s;
         int dr,mod,n,i;    int dr,mod,n,i;
         VECT result;    VECT result;
         V v;    V v;
   
         p = (P)ARG0(arg); mod = QTOS((Q)ARG1(arg));    p = (P)ARG0(arg); mod = QTOS((Q)ARG1(arg));
         v = VR(p);    v = VR(p);
         n = UDEG(p); mp = W_UMALLOC(n);    n = UDEG(p); mp = W_UMALLOC(n);
         ptoum(mod,p,mp);    ptoum(mod,p,mp);
         r = (UM *)W_ALLOC(n); s = (UM *)W_ALLOC(n);    r = (UM *)W_ALLOC(n); s = (UM *)W_ALLOC(n);
         r[0] = UMALLOC(0); DEG(r[0]) = 0; COEF(r[0])[0] = 1;    r[0] = UMALLOC(0); DEG(r[0]) = 0; COEF(r[0])[0] = 1;
         t = W_UMALLOC(mod); bzero(COEF(t),sizeof(int)*(mod+1));    t = W_UMALLOC(mod); bzero(COEF(t),sizeof(int)*(mod+1));
         DEG(t) = mod; COEF(t)[mod] = 1;    DEG(t) = mod; COEF(t)[mod] = 1;
         q = W_UMALLOC(mod);    q = W_UMALLOC(mod);
         dr = divum(mod,t,mp,q);    dr = divum(mod,t,mp,q);
         DEG(t) = dr; r[1] = r1 = UMALLOC(dr); cpyum(t,r1);    DEG(t) = dr; r[1] = r1 = UMALLOC(dr); cpyum(t,r1);
         s[0] = W_UMALLOC(dr); cpyum(t,s[0]);    s[0] = W_UMALLOC(dr); cpyum(t,s[0]);
         w = W_UMALLOC(n); bzero(COEF(w),sizeof(int)*(n+1));    w = W_UMALLOC(n); bzero(COEF(w),sizeof(int)*(n+1));
         w1 = W_UMALLOC(2*n); bzero(COEF(w1),sizeof(int)*(2*n+1));    w1 = W_UMALLOC(2*n); bzero(COEF(w1),sizeof(int)*(2*n+1));
         for ( i = 1; i < n; i++ ) {    for ( i = 1; i < n; i++ ) {
                 DEG(w) = i; COEF(w)[i-1] = 0; COEF(w)[i] = 1;      DEG(w) = i; COEF(w)[i-1] = 0; COEF(w)[i] = 1;
                 mulum(mod,r1,w,w1);      mulum(mod,r1,w,w1);
                 dr = divum(mod,w1,mp,q); DEG(w1) = dr;      dr = divum(mod,w1,mp,q); DEG(w1) = dr;
                 s[i] = W_UMALLOC(dr); cpyum(w1,s[i]);      s[i] = W_UMALLOC(dr); cpyum(w1,s[i]);
         }    }
         for ( i = 2; i < n; i++ ) {    for ( i = 2; i < n; i++ ) {
                 mult_mod_tab(r[i-1],mod,s,w,n);      mult_mod_tab(r[i-1],mod,s,w,n);
                 r[i] = UMALLOC(DEG(w)); cpyum(w,r[i]);      r[i] = UMALLOC(DEG(w)); cpyum(w,r[i]);
         }    }
         MKVECT(result,n);    MKVECT(result,n);
         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)  void reduce_sfdc(DCP sfdc,DCP *dcr)
 {  {
         P c,t,s,u,f;    P c,t,s,u,f;
         DCP dc0,dc,tdc;    DCP dc0,dc,tdc;
         DCP *a;    DCP *a;
         int i,j,n;    int i,j,n;
   
         if ( !current_gfs_ext ) {    if ( !current_gfs_ext ) {
                 /* we simply apply sfptop() */      /* we simply apply sfptop() */
                 for ( dc0 = 0; sfdc; sfdc = NEXT(sfdc) ) {      for ( dc0 = 0; sfdc; sfdc = NEXT(sfdc) ) {
                         NEXTDC(dc0,dc);        NEXTDC(dc0,dc);
                         DEG(dc) = DEG(sfdc);        DEG(dc) = DEG(sfdc);
                         sfptop(COEF(sfdc),&COEF(dc));        sfptop(COEF(sfdc),&COEF(dc));
                 }      }
                 NEXT(dc) = 0;      NEXT(dc) = 0;
                 *dcr = dc0;      *dcr = dc0;
                 return;      return;
         }    }
   
         if ( NUM(COEF(sfdc)) ) {    if ( NUM(COEF(sfdc)) ) {
                 sfptop(COEF(sfdc),&c);      sfptop(COEF(sfdc),&c);
                 sfdc = NEXT(sfdc);      sfdc = NEXT(sfdc);
         } else    } else
                 c = (P)ONE;      c = (P)ONE;
   
         for ( n = 0, tdc = sfdc; tdc; tdc = NEXT(tdc), n++ );    for ( n = 0, tdc = sfdc; tdc; tdc = NEXT(tdc), n++ );
         a = (DCP *)ALLOCA(n*sizeof(DCP));    a = (DCP *)ALLOCA(n*sizeof(DCP));
         for ( i = 0, tdc = sfdc; i < n; tdc = NEXT(tdc), i++ )    for ( i = 0, tdc = sfdc; i < n; tdc = NEXT(tdc), i++ )
                 a[i] = tdc;      a[i] = tdc;
   
         dc0 = 0; NEXTDC(dc0,dc); DEG(dc) = ONE; COEF(dc) = c;    dc0 = 0; NEXTDC(dc0,dc); DEG(dc) = ONE; COEF(dc) = c;
         for ( i = 0; i < n; i++ ) {    for ( i = 0; i < n; i++ ) {
                 if ( !a[i] )      if ( !a[i] )
                         continue;        continue;
                 t = COEF(a[i]);      t = COEF(a[i]);
                 f = t;      f = t;
                 while ( 1 ) {      while ( 1 ) {
                         sf_galois_action(t,ONE,&s);        sf_galois_action(t,ONE,&s);
                         for ( j = i; j < n; j++ )        for ( j = i; j < n; j++ )
                                 if ( a[j] && !compp(CO,s,COEF(a[j])) )          if ( a[j] && !compp(CO,s,COEF(a[j])) )
                                         break;            break;
                         if ( j == n )        if ( j == n )
                                 error("reduce_sfdc : cannot happen");          error("reduce_sfdc : cannot happen");
                         if ( j == i ) {        if ( j == i ) {
                                 NEXTDC(dc0,dc); DEG(dc) = DEG(a[i]);          NEXTDC(dc0,dc); DEG(dc) = DEG(a[i]);
                                 sfptop(f,&COEF(dc));          sfptop(f,&COEF(dc));
                                 break;          break;
                         } else {        } else {
                                 mulp(CO,f,s,&u); f = u;          mulp(CO,f,s,&u); f = u;
                                 t = s;          t = s;
                                 a[j] = 0;          a[j] = 0;
                         }        }
                 }      }
         }    }
         *dcr = dc0;    *dcr = dc0;
 }  }
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>