version 1.8, 2001/07/03 01:41:26 |
version 1.9, 2001/10/09 01:36:10 |
|
|
* 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/engine/M.c,v 1.7 2001/06/25 04:11:42 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/engine/M.c,v 1.8 2001/07/03 01:41:26 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "base.h" |
#include "base.h" |
|
|
void addum(mod,p1,p2,pr) |
void addum(int mod,UM p1,UM p2,UM pr) |
int mod; |
|
UM p1,p2,pr; |
|
{ |
{ |
register int *c1,*c2,*cr,i,dmax,dmin; |
register int *c1,*c2,*cr,i,dmax,dmin; |
|
|
|
|
DEG(pr) = dmax; |
DEG(pr) = dmax; |
} |
} |
|
|
void subum(mod,p1,p2,pr) |
void subum(int mod,UM p1,UM p2,UM pr) |
int mod; |
|
UM p1,p2,pr; |
|
{ |
{ |
register int *c1,*c2,*cr,i; |
register int *c1,*c2,*cr,i; |
int dmax,dmin; |
int dmax,dmin; |
|
|
DEG(pr) = dmax; |
DEG(pr) = dmax; |
} |
} |
|
|
void pwrum(mod,p,e,pr) |
void pwrum(int mod,UM p,int e,UM pr) |
int mod,e; |
|
UM p,pr; |
|
{ |
{ |
UM wt,ws; |
UM wt,ws; |
|
|
|
|
} |
} |
} |
} |
|
|
void gcdum(mod,p1,p2,pr) |
void gcdum(int mod,UM p1,UM p2,UM pr) |
register int mod; |
|
UM p1,p2,pr; |
|
{ |
{ |
register int inv; |
register int inv; |
UM t1,t2,q,tum; |
UM t1,t2,q,tum; |
|
|
} |
} |
} |
} |
|
|
void eucum(mod,f1,f2,a,b) |
void eucum(int mod,UM f1,UM f2,UM a,UM b) |
register int mod; |
|
UM f1,f2,a,b; |
|
{ |
{ |
UM g1,g2,a1,a2,a3,wm,q,tum; |
UM g1,g2,a1,a2,a3,wm,q,tum; |
int d,dr; |
int d,dr; |
UM t1,t2,t3; |
|
|
|
d = DEG(f1) + DEG(f2) + 10; |
d = DEG(f1) + DEG(f2) + 10; |
g1 = W_UMALLOC(d); g2 = W_UMALLOC(d); a1 = W_UMALLOC(d); |
g1 = W_UMALLOC(d); g2 = W_UMALLOC(d); a1 = W_UMALLOC(d); |
|
|
#endif |
#endif |
} |
} |
|
|
void eucum2(mod,f1,f2,a,b) |
void eucum2(int mod,UM f1,UM f2,UM a,UM b) |
register int mod; |
|
UM f1,f2,a,b; |
|
{ |
{ |
UM gk,gk1,gk2,ak,ak1,ak2,bk,bk1,bk2,q,t,wm1,wm2,wz; |
UM gk,gk1,gk2,ak,ak1,ak2,bk,bk1,bk2,q,t,wm1,wm2,wz; |
int d,inv; |
int d,inv; |
|
|
} |
} |
} |
} |
|
|
void sqfrum(index,count,f,nindex,dcr,pl) |
void sqfrum(int index,int count,P f,int *nindex,struct oDUM **dcr,ML *pl) |
int index,count,*nindex; |
|
P f; |
|
struct oDUM **dcr; |
|
ML *pl; |
|
{ |
{ |
int i,j,m,n,d,dt,mod; |
int i,j,m,n,d,dt,mod; |
UM wf,wdf,ws,wt,wgcd,mf,mgcd; |
UM wf,wdf,ws,wt,wgcd,mf,mgcd; |
|
|
l[i] = 0; |
l[i] = 0; |
} |
} |
|
|
void sqfrummain(mod,p,gcd,dcp) |
void sqfrummain(int mod,UM p,UM gcd,struct oDUM **dcp) |
int mod; |
|
UM p,gcd; |
|
struct oDUM **dcp; |
|
{ |
{ |
int i,j,n; |
int i,j,n; |
UM wp,wdp,wc,wd,ws,wt,wq; |
UM wp,wdp,wc,wd,ws,wt,wq; |
Line 417 struct oDUM **dcp; |
|
Line 397 struct oDUM **dcp; |
|
dc[j].f = 0; |
dc[j].f = 0; |
} |
} |
|
|
void cpyum(p1,p2) |
void cpyum(UM p1,UM p2) |
UM p1,p2; |
|
{ |
{ |
register int *c1,*c2,i; |
register int *c1,*c2,i; |
|
|
|
|
c2[i] = c1[i]; |
c2[i] = c1[i]; |
} |
} |
|
|
void clearum(p,n) |
void clearum(UM p,int n) |
UM p; |
|
int n; |
|
{ |
{ |
DEG(p) = -1; |
DEG(p) = -1; |
bzero(COEF(p),(n+1)*sizeof(int)); |
bzero(COEF(p),(n+1)*sizeof(int)); |
} |
} |
|
|
void degum(f,n) |
void degum(UM f,int n) |
UM f; |
|
int n; |
|
{ |
{ |
register int i,*c; |
register int i,*c; |
|
|
|
|
DEG(f) = i; |
DEG(f) = i; |
} |
} |
|
|
int deg(v,p) |
int deg(V v,P p) |
V v; |
|
P p; |
|
{ |
{ |
if ( !p ) |
if ( !p ) |
return ( -1 ); |
return ( -1 ); |
|
|
return ( UDEG(p) ); |
return ( UDEG(p) ); |
} |
} |
|
|
LUM LUMALLOC(n,bound) |
LUM LUMALLOC(int n,int bound) |
int n,bound; |
|
{ |
{ |
LUM p; |
LUM p; |
int **c; |
int **c; |
|
|
|
|
/* dx = deg in x, dy = deg in y, c[i] <-> the coef of y^i (poly in x) */ |
/* dx = deg in x, dy = deg in y, c[i] <-> the coef of y^i (poly in x) */ |
|
|
BM BMALLOC(dx,dy) |
BM BMALLOC(int dx,int dy) |
int dx,dy; |
|
{ |
{ |
BM p; |
BM p; |
UM *c; |
UM *c; |
|
|
return p; |
return p; |
} |
} |
|
|
void mullum(mod,n,f1,f2,fr) |
void mullum(int mod,int n,LUM f1,LUM f2,LUM fr) |
int mod,n; |
|
LUM f1,f2,fr; |
|
{ |
{ |
int max; |
int max; |
register int i,j,**p1,**p2,*px; |
register int i,j,**p1,**p2,*px; |
|
|
} |
} |
} |
} |
|
|
void cpylum(bound,p,r) |
void cpylum(int bound,LUM p,LUM r) |
int bound; |
|
LUM p,r; |
|
{ |
{ |
register int i,j; |
register int i,j; |
register int **pp,**ppr; |
register int **pp,**ppr; |
|
|
ppr[i][j] = pp[i][j]; |
ppr[i][j] = pp[i][j]; |
} |
} |
|
|
int isequalum(f1,f2) |
int isequalum(UM f1,UM f2) |
UM f1,f2; |
|
{ |
{ |
int i; |
int i; |
|
|
|
|
} |
} |
} |
} |
|
|
void pwrlum(mod,bound,p,n,r) |
void pwrlum(int mod,int bound,LUM p,int n,LUM r) |
int mod,bound,n; |
|
LUM p,r; |
|
{ |
{ |
LUM t,s; |
LUM t,s; |
|
|
|
|
} |
} |
} |
} |
|
|
int **almat(n,m) |
int **almat(int n,int m) |
int n,m; |
|
{ |
{ |
int **mat,i; |
int **mat,i; |
|
|
|
|
return mat; |
return mat; |
} |
} |
|
|
void mini(mod,f,fr) |
void mini(int mod,UM f,UM fr) |
register int mod; |
|
UM f,fr; |
|
{ |
{ |
register int i,j,**c,*ptr; |
register int i,j,**c,*ptr; |
int d,dr,dm,n; |
int d,dr,dm,n; |
|
|
DEG(fr) = dm + 1; |
DEG(fr) = dm + 1; |
} |
} |
|
|
int minimain(mod,n,m,c) |
int minimain(int mod,int n,int m,int **c) |
register int mod; |
|
int n,m; |
|
register int **c; |
|
{ |
{ |
register int *ptr,*ci,*p; |
register int *ptr,*ci,*p; |
register int i,l,a,j,b,inv; |
register int i,l,a,j,b,inv; |