===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/builtin/fctr.c,v
retrieving revision 1.11
retrieving revision 1.21
diff -u -p -r1.11 -r1.21
--- OpenXM_contrib2/asir2000/builtin/fctr.c	2002/01/09 07:45:40	1.11
+++ OpenXM_contrib2/asir2000/builtin/fctr.c	2004/05/13 14:02:16	1.21
@@ -45,22 +45,23 @@
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * 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.20 2004/05/13 12:12:43 takayama Exp $ 
 */
 #include "ca.h"
 #include "parse.h"
 
 void Pfctr(), Pgcd(), Pgcdz(), Plcm(), Psqfr(), Pufctrhint();
-void Pptozp(), Pcont();
+void Pptozp(), Pcont(), Psfcont();
 void Pafctr(), Pagcd();
 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 Pbivariate_hensel_special();
 
 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[] = {
+	{"bivariate_hensel_special",Pbivariate_hensel_special,6},
 	{"fctr",Pfctr,-2},
 	{"gcd",Pgcd,-3},
 	{"gcdz",Pgcdz,2},
@@ -69,14 +70,17 @@ struct ftab fctr_tab[] = {
 	{"ufctrhint",Pufctrhint,2},
 	{"ptozp",Pptozp,1},
 	{"cont",Pcont,-2},
+	{"sfcont",Psfcont,-2},
 	{"afctr",Pafctr,2},
 	{"agcd",Pagcd,3},
 	{"modsqfr",Pmodsqfr,2},
 	{"modfctr",Pmodfctr,2},
 	{"sfsqfr",Psfsqfr,1},
+	{"sffctr",Psffctr,1},
 	{"sfufctr",Psfufctr,1},
 	{"sfbfctr",Psfbfctr,-4},
 	{"sfmintdeg",Psfmintdeg,5},
+	{"sfgcd",Psfgcd,2},
 #if 0
 	{"ddd",Pddd,2},
 	{"newddd",Pnewddd,2},
@@ -87,6 +91,40 @@ struct ftab fctr_tab[] = {
 	{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)
 NODE arg;
 LIST *rp;
@@ -259,14 +297,84 @@ P *rp;
 	}
 }
 
-void Pptozp(arg,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)
+NODE arg;
+Obj *rp;
+{
 	Q t;
+    NODE opt,tt,p;
+    NODE n,n0;
+    char *key;
+	P pp;
+	LIST list;
+    int get_factor=0;
 
 	asir_assert(ARG0(arg),O_P,"ptozp");
-	ptozp((P)ARG0(arg),1,&t,rp);
+
+    /* analyze the option */
+    if ( argc(arg) == 2 && OID(ARG1(arg)) == O_OPTLIST ) {
+      opt = BDY((OPTLIST)ARG1(arg));
+      for ( tt = opt; 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)
@@ -308,30 +416,70 @@ int Divum();
 
 UM *resberle();
 
+void reduce_sfdc(DCP sfdc, DCP *dc);
+
 void Pmodfctr(arg,rp)
 NODE arg;
 LIST *rp;
 {
-	DCP dc;
-	int mod;
+	DCP dc,dcu;
+	int mod,i,t;
+	P p;
+	Obj u;
+	VL vl;
 
 	mod = QTOS((Q)ARG1(arg));
 	if ( mod < 0 )
 		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 = 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 ) {
 		NEWDC(dc); COEF(dc) = 0; DEG(dc) = ONE; NEXT(dc) = 0;
 	}
 	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)
 NODE arg;
 LIST *rp;
 {
 	DCP dc;
 
-	sfsqfr(ARG0(arg),&dc);
+	sqfrsf(CO,ARG0(arg),&dc);
 	dcptolist(dc,rp);
 }
 
@@ -341,7 +489,7 @@ LIST *rp;
 {
 	DCP dc;
 
-	fctrsf(ARG0(arg),&dc);
+	ufctrsf(ARG0(arg),&dc);
 	dcptolist(dc,rp);
 }
 
@@ -515,226 +663,59 @@ VECT *rp;
 	*rp = result;
 }
 
-struct lb {
-	int pos,len;
-	int *r;
-	int *hist;
-};
-
-static NODE insert_lb(NODE g,struct lb *a)
+void reduce_sfdc(DCP sfdc,DCP *dcr)
 {
-	NODE prev,cur,n;
+	P c,t,s,u,f;
+	DCP dc0,dc,tdc;
+	DCP *a;
+	int i,j,n;
 
-	prev = 0; cur = g;
-	while ( cur ) {
-		if ( a->pos < ((struct lb *)BDY(cur))->pos ) {
-			MKNODE(n,a,cur);
-			if ( !prev )
-				return n;
-			else {
-				NEXT(prev) = n;
-				return g;
-			}
-		} else {
-			prev = cur;
-			cur = NEXT(cur);
+	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;
 	}
-	MKNODE(n,a,0);
-	NEXT(prev) = n;
-	return g;
-}
 
-static void lnf(int *r,int *h,int n,int len,NODE g)
-{
-	struct lb *t;
-	int pos,i,j,len1,c;
-	int *r1,*h1;
+	if ( NUM(COEF(sfdc)) ) {
+		sfptop(COEF(sfdc),&c);
+		sfdc = NEXT(sfdc);
+	} else
+		c = (P)ONE;
 
-	for ( ; g; g = NEXT(g) ) {
-		t = (struct lb *)BDY(g);
-		pos = t->pos;
-		if ( c = r[pos] ) {
-			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);	
-	}
-}
+	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;
 
-void print_vect(int *r,int len)
-{
-	int i;
-
-	for ( i = 0; i < len; i++ )
-		if ( r[i] ) printf("(%d %d)",i,IFTOF(r[i]));
-	printf("\n");
-}
-
-void sfmintdeg(VL vl,P fx,int dy,int c,P *fr)
-{
-	V x,y;
-	int dx,dxdy,i,j,k,l,d,len,len0,u,dyk;
-	UP *rx;
-	DCP dc;
-	P t,f,mono,f1;
-	UP ut,h;
-	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));
-							}
-						}
-				}
+	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 {
-				prev = nf[d-1][i-1];
-				for ( k = 0, dyk = 0; k < dx; k++, dyk += dy ) {
-					for ( l = 1; l < dy; l++ )
-						r[dyk+l] = prev[dyk+l-1];
-				}
+				mulp(CO,f,s,&u); f = u;
+				t = s;
+				a[j] = 0;
 			}
-			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);
-			}
 		}
 	}
-}
-
-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;
+	*dcr = dc0;
 }