===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/engine/F.c,v
retrieving revision 1.1
retrieving revision 1.12
diff -u -p -r1.1 -r1.12
--- OpenXM_contrib2/asir2000/engine/F.c	1999/12/03 07:39:08	1.1
+++ OpenXM_contrib2/asir2000/engine/F.c	2013/01/08 07:25:58	1.12
@@ -1,13 +1,58 @@
-/* $OpenXM: OpenXM/src/asir99/engine/F.c,v 1.1.1.1 1999/11/10 08:12:26 noro Exp $ */
+/*
+ * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED 
+ * All rights reserved.
+ * 
+ * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
+ * non-exclusive and royalty-free license to use, copy, modify and
+ * redistribute, solely for non-commercial and non-profit purposes, the
+ * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
+ * conditions of this Agreement. For the avoidance of doubt, you acquire
+ * only a limited right to use the SOFTWARE hereunder, and FLL or any
+ * third party developer retains all rights, including but not limited to
+ * copyrights, in and to the SOFTWARE.
+ * 
+ * (1) FLL does not grant you a license in any way for commercial
+ * purposes. You may use the SOFTWARE only for non-commercial and
+ * non-profit purposes only, such as academic, research and internal
+ * business use.
+ * (2) The SOFTWARE is protected by the Copyright Law of Japan and
+ * international copyright treaties. If you make copies of the SOFTWARE,
+ * with or without modification, as permitted hereunder, you shall affix
+ * to all such copies of the SOFTWARE the above copyright notice.
+ * (3) An explicit reference to this SOFTWARE and its copyright owner
+ * shall be made on your publication or presentation in any form of the
+ * results obtained by use of the SOFTWARE.
+ * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
+ * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
+ * for such modification or the source code of the modified part of the
+ * SOFTWARE.
+ * 
+ * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
+ * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
+ * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
+ * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
+ * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
+ * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
+ * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
+ * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
+ * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
+ * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
+ * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
+ * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
+ * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
+ * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
+ * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
+ *
+ * $OpenXM: OpenXM_contrib2/asir2000/engine/F.c,v 1.11 2002/01/15 01:09:55 noro Exp $ 
+*/
 #include "ca.h"
 #include <math.h>
 
-void homfctr();
+int use_new_hensel;
 
-void fctrp(vl,f,dcp)
-VL vl;
-P f;
-DCP *dcp;
+void fctrp(VL vl,P f,DCP *dcp)
 {
 	VL nvl;
 	DCP dc;
@@ -27,11 +72,28 @@ DCP *dcp;
 	}
 }
 
-void homfctr(vl,g,dcp)
-VL vl;
-P g;
-DCP *dcp;
+void fctr_wrt_v_p(VL vl,P f,V v,DCP *dcp)
 {
+	VL nvl;
+	DCP dc;
+
+	if ( !f || NUM(f) ) {
+		NEWDC(dc); COEF(dc) = f; DEG(dc) = ONE;
+		NEXT(dc) = 0; *dcp = dc;
+		return;
+	} else if ( !qpcheck((Obj)f) )
+		error("fctrp : invalid argument");	
+	else {
+		clctv(vl,f,&nvl);
+		if ( !NEXT(nvl) ) 
+			ufctr(f,1,dcp);
+		else
+			mfctr_wrt_v(nvl,f,v,dcp);
+	}
+}
+
+void homfctr(VL vl,P g,DCP *dcp)
+{
 	P s,t,u,f,h,x;
 	Q e;
 	int d,d0;
@@ -50,10 +112,7 @@ DCP *dcp;
 	*dcp = dc;
 }
 
-void mfctr(vl,f,dcp)
-VL vl;
-P f;
-DCP *dcp;
+void mfctr(VL vl,P f,DCP *dcp)
 {
 	DCP dc,dc0,dct,dcs,dcr;
 	P p,pmin,ppmin,cmin,t;
@@ -71,6 +130,41 @@ DCP *dcp;
 #endif
 		pcp(mvl,pmin,&ppmin,&cmin);
 		if ( !NUM(cmin) ) {
+			mfctr(mvl,cmin,&dcs);
+			for ( dcr = NEXT(dcs); dcr; dcr = NEXT(dcr) ) {
+				DEG(dcr) = DEG(dct);
+				reorderp(vl,mvl,COEF(dcr),&t); COEF(dcr) = t;
+			}
+			for ( ; NEXT(dc); dc = NEXT(dc) );
+			NEXT(dc) = NEXT(dcs);
+		}
+		mfctrmain(mvl,ppmin,&dcs);
+		for ( dcr = dcs; dcr; dcr = NEXT(dcr) ) {
+			DEG(dcr) = DEG(dct);
+			reorderp(vl,mvl,COEF(dcr),&t); COEF(dcr) = t;
+		}
+		for ( ; NEXT(dc); dc = NEXT(dc) );
+		NEXT(dc) = dcs;
+	}
+	adjsgn(f,dc0); *dcp = dc0;
+}
+
+void mfctr_wrt_v(VL vl,P f,V v,DCP *dcp)
+{
+	DCP dc,dc0,dct,dcs,dcr;
+	P p,pmin,ppmin,cmin,t;
+	VL nvl,mvl;
+	Q c;
+
+	ptozp(f,1,&c,&p);
+	NEWDC(dc0); dc = dc0; COEF(dc) = (P)c; DEG(dc) = ONE; NEXT(dc) = 0;
+	msqfr(vl,p,&dct);
+	for ( ; dct; dct = NEXT(dct) ) {
+		clctv(vl,COEF(dct),&nvl);
+		reordvar(nvl,v,&mvl);
+		reorderp(mvl,vl,COEF(dct),&pmin);
+		pcp(mvl,pmin,&ppmin,&cmin);
+		if ( !NUM(cmin) ) {
 			mfctrmain(mvl,cmin,&dcs);
 			for ( dcr = dcs; dcr; dcr = NEXT(dcr) ) {
 				DEG(dcr) = DEG(dct);
@@ -90,9 +184,8 @@ DCP *dcp;
 	adjsgn(f,dc0); *dcp = dc0;
 }
 
-void adjsgn(p,dc)
-P p;
-DCP dc;
+#if 0
+void adjsgn(P p,DCP dc)
 {
 	int sgn;
 	DCP dct;
@@ -105,9 +198,23 @@ DCP dc;
 		chsgnp(COEF(dc),&c); COEF(dc) = c;
 	}
 }
+#else
+void adjsgn(P p,DCP dc)
+{     
+	DCP dct;
+	P c;
 
-int headsgn(p)
-P p;
+	if ( headsgn(COEF(dc)) != headsgn(p) ) {
+		chsgnp(COEF(dc),&c); COEF(dc) = c;
+	}
+	for ( dct = NEXT(dc); dct; dct = NEXT(dct) )
+		if ( headsgn(COEF(dct)) < 0 ) {
+			chsgnp(COEF(dct),&c); COEF(dct) = c;
+		}
+}
+#endif
+
+int headsgn(P p)
 {
 	if ( !p )
 		return 0;
@@ -118,11 +225,7 @@ P p;
 	}
 }
 
-void fctrwithmvp(vl,f,v,dcp)
-VL vl;
-P f;
-V v;
-DCP *dcp;
+void fctrwithmvp(VL vl,P f,V v,DCP *dcp)
 {
 	VL nvl;
 	DCP dc;
@@ -140,11 +243,7 @@ DCP *dcp;
 		mfctrwithmv(nvl,f,v,dcp);
 }
 
-void mfctrwithmv(vl,f,v,dcp)
-VL vl;
-P f;
-V v;
-DCP *dcp;
+void mfctrwithmv(VL vl,P f,V v,DCP *dcp)
 {
 	DCP dc,dc0,dct,dcs,dcr;
 	P p,pmin,ppmin,cmin,t;
@@ -181,10 +280,7 @@ DCP *dcp;
 	*dcp = dc0;
 }
 
-void ufctr(f,hint,dcp)
-P f;
-int hint;
-DCP *dcp;
+void ufctr(P f,int hint,DCP *dcp)
 {
 	P p,c;
 	DCP dc,dct,dcs,dcr;
@@ -201,18 +297,16 @@ DCP *dcp;
 	}
 }
 
-void mfctrmain(vl,p,dcp)
-VL vl;
-P p;
-DCP *dcp;
+void mfctrmain(VL vl,P p,DCP *dcp)
 {
-	int i,j,k,*win,np;
+	int i,j,k,*win,np,x;
 	VL nvl,tvl;
 	VN vn,vnt,vn1;
 	P p0,f,g,f0,g0,s,t,lp,m;
 	P *fp0,*fpt,*l,*tl;
 	DCP dc,dc0,dcl;
 	int count,nv;
+	int *nonzero;
 
 	if ( !cmpq(DEG(DC(p)),ONE) ) {
 		NEWDC(dc); DEG(dc) = ONE; COEF(dc) = p; NEXT(dc) = 0;
@@ -222,9 +316,56 @@ DCP *dcp;
 	for ( nv = 0, tvl = nvl; tvl; tvl = NEXT(tvl), nv++);
 	W_CALLOC(nv,struct oVN,vn); W_CALLOC(nv,struct oVN,vnt);
 	W_CALLOC(nv,struct oVN,vn1);
+	W_CALLOC(nv,int,nonzero);
+
 	for ( i = 0, tvl = NEXT(nvl); tvl; tvl = NEXT(tvl), i++ ) 
 		vn1[i].v = vn[i].v = tvl->v;
 	vn1[i].v = vn[i].v = 0;
+
+	/* determine a heuristic bound of deg(GCD(p,p')) */
+	while ( 1 ) {
+		for ( i = 0; vn1[i].v; i++ )
+			vn1[i].n = ((unsigned int)random())%256+1;
+		substvp(nvl,LC(p),vn1,&p0);
+		if ( p0 ) {
+			substvp(nvl,p,vn1,&p0);
+			if ( sqfrchk(p0) ) {
+				ufctr(p0,1,&dc0); 
+				if ( NEXT(NEXT(dc0)) == 0 ) {
+					NEWDC(dc); DEG(dc) = ONE; COEF(dc) = p; NEXT(dc) = 0;
+					*dcp = dc;
+					return;
+				} else {
+					for ( dc0 = NEXT(dc0), np = 0; dc0; dc0 = NEXT(dc0), np++ );
+					break;
+				}
+			}
+		}
+	}
+	
+	/* determine the position of variables which is not allowed to
+	   be set to 0 */
+	for ( i = 0; vn1[i].v; i++ ) {
+		x = vn1[i].n; vn1[i].n = 0;
+		substvp(nvl,LC(p),vn1,&p0);
+		if ( !p0 )
+			vn1[i].n = x;
+		else {
+			substvp(nvl,p,vn1,&p0);
+			if ( !sqfrchk(p0) )
+				vn1[i].n = x;
+			else {
+				ufctr(p0,1,&dc0); 
+				for ( dc0 = NEXT(dc0), j = 0; dc0; dc0 = NEXT(dc0), j++ );
+				if ( j > np )
+					vn1[i].n = x;
+			}
+		}
+	}
+	for ( i = 0; vn1[i].v; i++ )
+		if (vn1[i].n )
+			nonzero[i] = 1;
+
 	count = 0;
 	while  ( 1 ) {
 		while ( 1 ) {
@@ -248,14 +389,26 @@ DCP *dcp;
 						NEWDC(dc); DEG(dc) = ONE; COEF(dc) = p; NEXT(dc) = 0;
 						*dcp = dc;
 						return;
-					} else
-						goto MAIN;
-				} 
+					} else {
+						for ( dc = NEXT(dc0), i = 0; dc; dc = NEXT(dc), i++ );
+						if ( i <= np )
+							goto MAIN;
+						if ( i < np )
+							np = i;
+					}
+				}
 			}
 			if ( nextbin(vnt,j) ) 
 				break;
 		}
-		next(vn);
+		while ( 1 ) {
+			next(vn);
+			for ( i = 0; vn[i].v; i++ )
+				if ( nonzero[i] && !vn[i].n )
+					break;
+			if ( !vn[i].v )
+				break;
+		}
 	}
 MAIN :
 #if 0
@@ -320,10 +473,7 @@ MAIN :
 	NEXT(dc) = 0; *dcp = dc0;
 }
 
-void ufctrmain(p,hint,dcp)
-P p;
-int hint;
-DCP *dcp;
+void ufctrmain(P p,int hint,DCP *dcp)
 {
 	ML list;
 	DCP dc;
@@ -336,7 +486,10 @@ DCP *dcp;
 	else if ( iscycp(p) )
 		cycp(VR(p),UDEG(p),dcp);
 	else {
-		hensel(5,5,p,&list);
+		if ( use_new_hensel )
+			hensel2(5,5,p,&list);
+		else
+			hensel(5,5,p,&list);
 		if ( list->n == 1 ) {
 			NEWDC(dc); DEG(dc) = ONE; COEF(dc) = p; NEXT(dc) = 0;
 			*dcp = dc;
@@ -345,17 +498,7 @@ DCP *dcp;
 	}
 }
 
-struct oMF {
-	int m;
-	P f;
-};
-
-void calcphi();
-
-void cycm(v,n,dcp)
-V v;
-register int n;
-DCP *dcp;
+void cycm(V v,int n,DCP *dcp)
 {
 	register int i,j;
 	struct oMF *mfp;
@@ -378,10 +521,7 @@ DCP *dcp;
 	NEXT(dc) = 0; *dcp = dc0;
 }
 
-void cycp(v,n,dcp)
-V v;
-register int n;
-DCP *dcp;
+void cycp(V v,int n,DCP *dcp)
 {
 	register int i,j;
 	int n0;
@@ -407,10 +547,7 @@ DCP *dcp;
 	NEXT(dc) = 0; *dcp = dc0;
 }
 
-void calcphi(v,n,mfp)
-V v;
-int n;
-register struct oMF *mfp;
+void calcphi(V v,int n,struct oMF *mfp)
 {
 	register int i,m;
 	P t,s,tmp;
@@ -424,10 +561,7 @@ register struct oMF *mfp;
 		error("calcphi: cannot happen");
 }
 
-void mkssum(v,e,s,sgn,r)
-V v;
-int e,s,sgn;
-P *r;
+void mkssum(V v,int e,int s,int sgn,P *r)
 {
 	register int i,sgnt;
 	DCP dc,dc0;
@@ -444,8 +578,7 @@ P *r;
 	NEXT(dc) = 0; MKP(v,dc0,*r);
 }
 
-int iscycp(f)
-P f;
+int iscycp(P f)
 {
 	DCP dc;
 	dc = DC(f);
@@ -458,8 +591,7 @@ P f;
 	return ( 1 );	
 }
 
-int iscycm(f)
-P f;
+int iscycm(P f)
 {
 	DCP dc;
 
@@ -472,8 +604,7 @@ P f;
 	return ( 1 );	
 }
 
-void sortfs(dcp)
-DCP *dcp;
+void sortfs(DCP *dcp)
 {
 	int i,k,n,k0,d;
 	DCP dc,dct,t;
@@ -501,8 +632,7 @@ DCP *dcp;
 	NEXT(dct) = 0;
 }
 
-void sortfsrev(dcp)
-DCP *dcp;
+void sortfsrev(DCP *dcp)
 {
 	int i,k,n,k0,d;
 	DCP dc,dct,t;
@@ -530,11 +660,7 @@ DCP *dcp;
 	NEXT(dct) = 0;
 }
 
-void nthrootchk(f,dc,fp,dcp)
-P f;
-struct oDUM *dc;
-ML fp;
-DCP *dcp;
+void nthrootchk(P f,struct oDUM *dc,ML fp,DCP *dcp)
 {
 	register int i,k;
 	int e,n,dr,tmp,t;
@@ -585,10 +711,7 @@ DCP *dcp;
 	}
 }
 
-void sqfrp(vl,f,dcp)
-VL vl;
-P f;
-DCP *dcp;
+void sqfrp(VL vl,P f,DCP *dcp)
 {
 	P c,p;
 	DCP dc,dc0;
@@ -609,10 +732,7 @@ DCP *dcp;
 /* 
  * f : must be a poly with int coef, ignore int content
  */
-void msqfr(vl,f,dcp)
-VL vl;
-P f;
-DCP *dcp;
+void msqfr(VL vl,P f,DCP *dcp)
 {
 	DCP dc,dct,dcs;
 	P c,p,t,s,pc;
@@ -650,9 +770,7 @@ DCP *dcp;
 	}
 }
 
-void usqp(f,dcp)
-P f;
-DCP *dcp;
+void usqp(P f,DCP *dcp)
 {
 	int index,nindex;
 	P g,c,h;
@@ -668,10 +786,7 @@ DCP *dcp;
 	*dcp = dc;
 }
 
-void msqfrmain(vl,p,dcp)
-VL vl;
-P p;
-DCP *dcp;
+void msqfrmain(VL vl,P p,DCP *dcp)
 {
 	int i,j;
 	VL nvl,tvl;
@@ -710,7 +825,31 @@ DCP *dcp;
 		vn1[i].v = vn[i].v = tvl->v;
 	vn1[i].v = vn[i].v = 0;
 
-	for  ( dcr0 = 0, g = p, d = deg(VR(g),g), found = 0; ; ) {
+	/* determine a heuristic bound of deg(GCD(p,p')) */
+	while ( 1 ) {
+		for ( i = 0; vn1[i].v; i++ )
+			vn1[i].n = ((unsigned int)random())%256+1;
+		substvp(nvl,LC(p),vn1,&tmp);
+		if ( tmp ) {
+			substvp(nvl,p,vn1,&p0);
+			usqp(p0,&dc0);
+			for ( d1 = 0, dc = dc0; dc; dc = NEXT(dc) )
+				if ( DEG(dc) )
+					d1 += (QTOS(DEG(dc))-1)*UDEG(COEF(dc));
+			if ( d1 == 0 ) {
+				/* p is squarefree */
+				NEWDC(dc); DEG(dc) = ONE; COEF(dc) = p; NEXT(dc) = 0;
+				*dcp = dc;
+				return;
+			} else {
+				d = d1+1; /* XXX : try searching better evaluation */
+				found = 0;
+				break;
+			}
+		}
+	}
+
+	for  ( dcr0 = 0, g = p; ; ) {
 		while ( 1 ) {
 			for ( i = 0, j = 0; vn[i].v; i++ ) 
 				if ( vn[i].n ) vnt[j++].v = (V)i;
@@ -775,14 +914,7 @@ END:
 	}
 }
 
-void msqfrmainmain(vl,p,vn,p0,dc0,dcp,pp)
-VL vl;
-P p;
-VN vn;
-P p0;
-DCP dc0;
-DCP *dcp;
-P *pp;
+void msqfrmainmain(VL vl,P p,VN vn,P p0,DCP dc0,DCP *dcp,P *pp)
 {
 	int i,j,k,np;
 	DCP *a;
@@ -882,12 +1014,7 @@ P *pp;
 	*dcp = dcr0;
 }
 
-void mfctrhen2(vl,vn,f,f0,g0,h0,lcg,lch,gp)
-VL vl;
-VN vn;
-P f;
-P f0,g0,h0,lcg,lch;
-P *gp;
+void mfctrhen2(VL vl,VN vn,P f,P f0,P g0,P h0,P lcg,P lch,P *gp)
 {
 	V v;
 	P f1,lc,lc0,lcg0,lch0;
@@ -933,8 +1060,7 @@ P *gp;
 		*gp = 0;
 }
 
-int sqfrchk(p)
-P p;
+int sqfrchk(P p)
 {
 	Q c;
 	P f;
@@ -947,8 +1073,7 @@ P p;
 		return ( 1 );
 }
 
-int cycchk(p)
-P p;
+int cycchk(P p)
 {
 	Q c;
 	P f;
@@ -960,10 +1085,7 @@ P p;
 		return 1;
 }
 
-int zerovpchk(vl,p,vn)
-VL vl;
-P p;
-VN vn;
+int zerovpchk(VL vl,P p,VN vn)
 {
 	P t;
 
@@ -974,10 +1096,7 @@ VN vn;
 		return ( 1 );
 }
 
-int valideval(vl,dc,vn)
-VL vl;
-DCP dc;
-VN vn;
+int valideval(VL vl,DCP dc,VN vn)
 {
 	DCP dct;
 	Q *a;
@@ -1003,12 +1122,7 @@ VN vn;
 	return ( 1 );
 }
 
-void estimatelc(vl,c,dc,vn,lcp)
-VL vl;
-Q c;
-DCP dc;
-VN vn;
-P *lcp;
+void estimatelc(VL vl,Q c,DCP dc,VN vn,P *lcp)
 {
 	int i;
 	DCP dct;
@@ -1036,11 +1150,7 @@ P *lcp;
 	*lcp = r;
 }
 
-void monomialfctr(vl,p,pr,dcp)
-VL vl;
-P p;
-P *pr;
-DCP *dcp;
+void monomialfctr(VL vl,P p,P *pr,DCP *dcp)
 {
 	VL nvl,avl;
 	Q d;
@@ -1060,10 +1170,7 @@ DCP *dcp;
 	*pr = f; *dcp = dc0;
 }
 
-void afctr(vl,p0,p,dcp)
-VL vl;
-P p,p0;
-DCP *dcp;
+void afctr(VL vl,P p0,P p,DCP *dcp)
 {
 	DCP dc,dc0,dcr,dct,dcs;
 	P t;
@@ -1106,11 +1213,7 @@ DCP *dcp;
 	*dcp = dc0;
 }
 
-void afctrmain(vl,p0,p,init,dcp)
-VL vl;
-P p,p0;
-int init;
-DCP *dcp;
+void afctrmain(VL vl,P p0,P p,int init,DCP *dcp)
 {
 	P x,y,s,m,a,t,u,pt,pt1,res,g;
 	Q q;