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

Diff for /OpenXM_contrib2/asir2000/builtin/gf.c between version 1.5 and 1.15

version 1.5, 2001/05/09 01:41:41 version 1.15, 2002/03/15 02:52:09
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/gf.c,v 1.4 2000/08/22 05:03:57 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/gf.c,v 1.14 2001/10/09 01:36:06 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 56  struct resf_dlist {
Line 56  struct resf_dlist {
   
 int resf_degtest(int,int *,int,struct resf_dlist *);  int resf_degtest(int,int *,int,struct resf_dlist *);
 void uhensel(P,NODE,int,int,NODE *);  void uhensel(P,NODE,int,int,NODE *);
   void uhensel_incremental(P,NODE,int,int,int,NODE *);
 void resf_hensel(int,P,int,P *,ML *);  void resf_hensel(int,P,int,P *,ML *);
 void resf_dtest(P,ML,int,int *,int *,DCP *);  void resf_dtest(P,ML,int,int *,int *,DCP *);
 void resf_dtest_special(P,ML,int,int *,int *,DCP *);  void resf_dtest_special(P,ML,int,int *,int *,DCP *);
Line 67  void nullspace_lm(LM **,int,int *);
Line 68  void nullspace_lm(LM **,int,int *);
 void nullspace_gf2n(GF2N **,int,int *);  void nullspace_gf2n(GF2N **,int,int *);
 void nullspace_gfpn(GFPN **,int,int *);  void nullspace_gfpn(GFPN **,int,int *);
 void nullspace_gfs(GFS **,int,int *);  void nullspace_gfs(GFS **,int,int *);
   void nullspace_gfsn(GFSN **,int,int *);
 void null_to_sol(int **,int *,int,int,UM *);  void null_to_sol(int **,int *,int,int,UM *);
   
 void showgfmat(UM **,int);  void showgfmat(UM **,int);
Line 74  void pwr_mod(P,P,V,P,int,N,P *);
Line 76  void pwr_mod(P,P,V,P,int,N,P *);
 void rem_mod(P,P,V,P,int,P *);  void rem_mod(P,P,V,P,int,P *);
   
 void Pnullspace(),Pgcda_mod(),Pftest(),Presfmain(),Ppwr_mod(),Puhensel();  void Pnullspace(),Pgcda_mod(),Pftest(),Presfmain(),Ppwr_mod(),Puhensel();
   void Puhensel_incremental();
   void Psfuhensel();
   
 void Pnullspace_ff();  void Pnullspace_ff();
   
Line 83  void Plinear_form_to_vect(),Pvect_to_linear_form();
Line 87  void Plinear_form_to_vect(),Pvect_to_linear_form();
 void solve_linear_equation_gf2n(GF2N **,int,int,int *);  void solve_linear_equation_gf2n(GF2N **,int,int,int *);
 void linear_form_to_array(P,VL,int,Num *);  void linear_form_to_array(P,VL,int,Num *);
 void array_to_linear_form(Num *,VL,int,P *);  void array_to_linear_form(Num *,VL,int,P *);
   void sfuhensel(P,NODE,GFS,int,NODE *);
   
 extern int current_ff;  extern int current_ff;
   
Line 95  struct ftab gf_tab[] = {
Line 100  struct ftab gf_tab[] = {
         {"resfmain",Presfmain,4},          {"resfmain",Presfmain,4},
         {"pwr_mod",Ppwr_mod,6},          {"pwr_mod",Ppwr_mod,6},
         {"uhensel",Puhensel,4},          {"uhensel",Puhensel,4},
           {"uhensel_incremental",Puhensel_incremental,5},
           {"sfuhensel",Psfuhensel,4},
         {0,0,0},          {0,0,0},
 };  };
   
Line 147  LIST *rp;
Line 154  LIST *rp;
         MKLIST(*rp,r);          MKLIST(*rp,r);
 }  }
   
   void Puhensel_incremental(arg,rp)
   NODE arg;
   LIST *rp;
   {
           P f;
           NODE mfl,r;
           int mod,bound,start;
   
           f = (P)ARG0(arg);
           mfl = BDY((LIST)ARG1(arg));
           mod = QTOS((Q)ARG2(arg));
           start = QTOS((Q)ARG3(arg));
           bound = QTOS((Q)ARG4(arg));
           uhensel_incremental(f,mfl,mod,start,bound,&r);
           MKLIST(*rp,r);
   }
   
 void uhensel(f,mfl,mod,bound,rp)  void uhensel(f,mfl,mod,bound,rp)
 P f;  P f;
 NODE mfl;  NODE mfl;
Line 179  NODE *rp;
Line 203  NODE *rp;
         *rp = top;          *rp = top;
 }  }
   
   void uhensel_incremental(f,mfl,mod,start,bound,rp)
   P f;
   NODE mfl;
   int mod,start,bound;
   NODE *rp;
   {
           ML blist,clist,rlist;
           LUM fl;
           LUM *lblist;
           int nf,i,j,k;
           int **p;
           P s;
           V v;
           NODE t,top;
   
           nf = length(mfl);
           blist = MLALLOC(nf); blist->n = nf; blist->mod = mod;
           lblist = (LUM *)MALLOC(nf*sizeof(LUM));
           for ( i = 0, t = mfl; i < nf; i++, t = NEXT(t) ) {
                   blist->c[i] = (pointer)UMALLOC(UDEG((P)BDY(t)));
                   ptoum(mod,(P)BDY(t),blist->c[i]);
                   W_LUMALLOC((int)UDEG((P)BDY(t)),bound,lblist[i]);
                   ptolum(mod,start,(P)BDY(t),lblist[i]);
                   p = lblist[i]->c;
                   for ( j = DEG(lblist[i]); j >= 0; j-- )
                           for ( k = start; k < bound; k++ )
                                   p[j][k] = 0;
           }
           gcdgen(f,blist,&clist);
           clist->bound = bound;
           W_LUMALLOC((int)UDEG(f),bound,fl);
           ptolum(mod,bound,f,fl);
           henmain_incremental(fl,lblist,clist,nf,mod,start,bound);
           v = VR(f);
           for ( i = nf-1, top = 0; i >= 0; i-- ) {
                   lumtop_unsigned(v,mod,bound,lblist[i],&s);
                   MKNODE(t,s,top); top = t;
           }
           *rp = top;
   }
   
   void Psfuhensel(arg,rp)
   NODE arg;
   LIST *rp;
   {
           P f;
           int bound;
           NODE r,mfl;
           GFS ev;
   
           f = (P)ARG0(arg);
           mfl = BDY((LIST)ARG1(arg));
           ev = (GFS)ARG2(arg);
           bound = QTOS((Q)ARG3(arg));
           sfuhensel(f,mfl,ev,bound,&r);
           MKLIST(*rp,r);
   }
   
   void sfuhensel(f,mfl,ev,bound,rp)
   P f;
   NODE mfl;
   GFS ev;
   int bound;
   NODE *rp;
   {
           BM fl;
           BM *r;
           VL vl,nvl;
           int i,fn,dx,dy,d;
           NODE t,top;
           UM fm,hm,q;
           UM *gm;
           V x,y;
           P g,s,u;
   
           clctv(CO,f,&vl);
           if ( !vl || !vl->next || vl->next->next )
                   error("sfuhensel : f must be a bivariate poly");
   
           for ( i = 0, t = mfl; t; i++, t = NEXT(t) );
           fn = i;
   
           gm = (UM *)MALLOC(fn*sizeof(UM));
   
           /* XXX : more severe check is necessary */
           x = VR((P)BDY(mfl));
           y = vl->v == x ? vl->next->v : vl->v;
   
           for ( i = 0, t = mfl, d = 0; i < fn; i++, t = NEXT(t) ) {
                   gm[i] = (pointer)UMALLOC(getdeg(x,(P)BDY(t)));
                   ptosfum((P)BDY(t),gm[i]);
                   d += DEG(gm[i]);
           }
   
           /* reorder f if necessary */
           if ( vl->v != x ) {
                   reordvar(vl,x,&nvl); reorderp(nvl,vl,f,&g);
                   vl = nvl; f = g;
           }
           dx = getdeg(x,f);
           if ( dx != d )
                   error("sfuhensel : product of factors has incompatible degree");
   
           dy = getdeg(y,f);
           dy = MAX(dy,bound);
           fl = BMALLOC(dx,dy);
           ptosfbm(dy,f,fl);
           if ( ev ) shiftsfbm(fl,FTOIF(CONT(ev)));
   
           /* fm = fl mod y */
           fm = W_UMALLOC(dx);
           cpyum(COEF(fl)[0],fm);
           hm = W_UMALLOC(dx);
   
           q = W_UMALLOC(dx);
           r = (BM *)MLALLOC(fn*sizeof(BM));
           for ( i = 0; i < fn-1; i++ ) {
                   /* fl = gm[i]*hm mod y */
                   divsfum(fm,gm[i],hm);
                   /* fl is replaced by the cofactor of gk mod y^bound */
                   /* r[i] = gk */
                   sfhenmain2(fl,gm[i],hm,bound,r+i);
                   cpyum(hm,fm);
           }
           /* finally, fl must be the lift of gm[fn-1] */
           r[i] = fl;
   
           for ( i = fn-1, top = 0; i >= 0; i-- ) {
                   sfbmtop(r[i],x,y,&s);
                   reorderp(CO,vl,s,&u);
                   MKNODE(t,u,top); top = t;
           }
           *rp = top;
   }
   
 void Presfmain(arg,rp)  void Presfmain(arg,rp)
 NODE arg;  NODE arg;
 LIST *rp;  LIST *rp;
Line 786  NODE arg;
Line 945  NODE arg;
 LIST *rp;  LIST *rp;
 {  {
         int i,j,n;          int i,j,n;
         Q mod;  
         MAT mat,r;          MAT mat,r;
         VECT u;          VECT u;
         Q q;          Q q;
Line 812  LIST *rp;
Line 970  LIST *rp;
                         nullspace_gfpn((GFPN **)w,n,ind); break;                          nullspace_gfpn((GFPN **)w,n,ind); break;
                 case FF_GFS:                  case FF_GFS:
                         nullspace_gfs((GFS **)w,n,ind); break;                          nullspace_gfs((GFS **)w,n,ind); break;
                   case FF_GFSN:
                           nullspace_gfsn((GFSN **)w,n,ind); break;
                 default:                  default:
                         error("nullspace_ff : current_ff is not set");                          error("nullspace_ff : current_ff is not set");
         }          }
Line 988  int *ind;
Line 1148  int *ind;
                         chsgngfs(u[j],&h);                          chsgngfs(u[j],&h);
                         for ( s = j; s < n; s++ ) {                          for ( s = j; s < n; s++ ) {
                                 mulgfs(h,t[s],&w); addgfs(w,u[s],&w1); u[s] = w1;                                  mulgfs(h,t[s],&w); addgfs(w,u[s],&w1); u[s] = w1;
                           }
                   }
           }
   }
   
   void nullspace_gfsn(mat,n,ind)
   GFSN **mat;
   int n;
   int *ind;
   {
           int i,j,l,s;
           GFSN w,w1,h,inv;
           GFSN *t,*u;
   
           bzero(ind,n*sizeof(int));
           ind[0] = 0;
   
           for ( i = j = 0; j < n; i++, j++ ) {
                   for ( ; j < n; j++ ) {
                           for ( l = i; l < n; l++ )
                                   if ( mat[l][j] )
                                           break;
                           if ( l < n ) {
                                   t = mat[i]; mat[i] = mat[l]; mat[l] = t; break;
                           } else
                                   ind[j] = 1;
                   }
                   if ( j == n )
                           break;
                   invgfsn(mat[i][j],&inv);
                   for ( s = j, t = mat[i]; s < n; s++ ) {
                           mulgfsn(t[s],inv,&w); t[s] = w;
                   }
                   for ( l = 0; l < n; l++ ) {
                           if ( l == i )
                                   continue;
                           u = mat[l];
                           chsgngfsn(u[j],&h);
                           for ( s = j; s < n; s++ ) {
                                   mulgfsn(h,t[s],&w); addgfsn(w,u[s],&w1); u[s] = w1;
                         }                          }
                 }                  }
         }          }
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.15
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>