version 1.8, 2000/12/05 08:29:44 |
version 1.19, 2012/12/17 07:20:44 |
|
|
* 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/distm.c,v 1.7 2000/12/05 06:59:16 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/engine/distm.c,v 1.18 2003/12/26 02:38:10 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "inline.h" |
#include "inline.h" |
|
|
extern int (*cmpdl)(); |
extern int (*cmpdl)(); |
extern int do_weyl; |
extern int do_weyl; |
|
|
void comm_mulmd(); |
void ptomd(VL vl,int mod,VL dvl,P p,DP *pr) |
void weyl_mulmd(); |
|
void weyl_mulmdm(); |
|
void weyl_mulmmm(); |
|
|
|
void mulmdm_dup(); |
|
void comm_mulmd_dup(); |
|
void weyl_mulmd_dup(); |
|
void weyl_mulmdm_dup(); |
|
void weyl_mulmmm_dup(); |
|
void comm_mulmd_tab_destructive(); |
|
void adddl_dup(); |
|
void ptomd(vl,mod,dvl,p,pr) |
|
VL vl,dvl; |
|
int mod; |
|
P p; |
|
DP *pr; |
|
{ |
{ |
P t; |
P t; |
|
|
|
|
mptomd(vl,mod,dvl,t,pr); |
mptomd(vl,mod,dvl,t,pr); |
} |
} |
|
|
void mptomd(vl,mod,dvl,p,pr) |
void mptomd(VL vl,int mod,VL dvl,P p,DP *pr) |
VL vl,dvl; |
|
int mod; |
|
P p; |
|
DP *pr; |
|
{ |
{ |
int n,i; |
int n,i; |
VL tvl; |
VL tvl; |
|
|
} else { |
} else { |
for ( dc = DC(p), s = 0; dc; dc = NEXT(dc) ) { |
for ( dc = DC(p), s = 0; dc; dc = NEXT(dc) ) { |
mptomd(vl,mod,dvl,COEF(dc),&t); |
mptomd(vl,mod,dvl,COEF(dc),&t); |
NEWDL(d,n); d->td = QTOS(DEG(dc)); d->d[i] = d->td; |
NEWDL(d,n); d->d[i] = QTOS(DEG(dc)); |
|
d->td = MUL_WEIGHT(d->d[i],i); |
NEWMP(m); m->dl = d; C(m) = (P)ONEM; NEXT(m) = 0; MKDP(n,m,u); |
NEWMP(m); m->dl = d; C(m) = (P)ONEM; NEXT(m) = 0; MKDP(n,m,u); |
comm_mulmd(vl,mod,t,u,&r); addmd(vl,mod,r,s,&t); s = t; |
comm_mulmd(vl,mod,t,u,&r); addmd(vl,mod,r,s,&t); s = t; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void mdtop(vl,mod,dvl,p,pr) |
void mdtodp(DP p,DP *pr) |
VL vl,dvl; |
|
int mod; |
|
DP p; |
|
P *pr; |
|
{ |
{ |
|
MP m,mr0,mr; |
|
|
|
if ( !p ) |
|
*pr = 0; |
|
else { |
|
for ( m = BDY(p), mr0 = 0; m; m = NEXT(m) ) { |
|
NEXTMP(mr0,mr); mr->dl = m->dl; |
|
mptop(C(m),&C(mr)); |
|
} |
|
NEXT(mr) = 0; |
|
MKDP(NV(p),mr0,*pr); |
|
(*pr)->sugar = p->sugar; |
|
} |
|
} |
|
|
|
void _mdtodp(DP p,DP *pr) |
|
{ |
|
MP m,mr0,mr; |
|
int i; |
|
Q q; |
|
|
|
if ( !p ) |
|
*pr = 0; |
|
else { |
|
for ( m = BDY(p), mr0 = 0; m; m = NEXT(m) ) { |
|
NEXTMP(mr0,mr); mr->dl = m->dl; |
|
i = ITOS(m->c); STOQ(i,q); C(mr) = (P)q; |
|
} |
|
NEXT(mr) = 0; |
|
MKDP(NV(p),mr0,*pr); |
|
(*pr)->sugar = p->sugar; |
|
} |
|
} |
|
|
|
void mdtop(VL vl,int mod,VL dvl,DP p,P *pr) |
|
{ |
int n,i; |
int n,i; |
DL d; |
DL d; |
MP m; |
MP m; |
|
|
} |
} |
} |
} |
|
|
void addmd(vl,mod,p1,p2,pr) |
void addmd(VL vl,int mod,DP p1,DP p2,DP *pr) |
VL vl; |
|
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
int n; |
int n; |
MP m1,m2,mr,mr0; |
MP m1,m2,mr,mr0; |
|
|
} |
} |
} |
} |
|
|
void submd(vl,mod,p1,p2,pr) |
void submd(VL vl,int mod,DP p1,DP p2,DP *pr) |
VL vl; |
|
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
DP t; |
DP t; |
|
|
|
|
} |
} |
} |
} |
|
|
void chsgnmd(mod,p,pr) |
void chsgnmd(int mod,DP p,DP *pr) |
int mod; |
|
DP p,*pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
|
|
|
|
} |
} |
} |
} |
|
|
void mulmd(vl,mod,p1,p2,pr) |
void mulmd(VL vl,int mod,DP p1,DP p2,DP *pr) |
VL vl; |
|
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
if ( !do_weyl ) |
if ( !do_weyl ) |
comm_mulmd(vl,mod,p1,p2,pr); |
comm_mulmd(vl,mod,p1,p2,pr); |
|
|
weyl_mulmd(vl,mod,p1,p2,pr); |
weyl_mulmd(vl,mod,p1,p2,pr); |
} |
} |
|
|
void comm_mulmd(vl,mod,p1,p2,pr) |
void comm_mulmd(VL vl,int mod,DP p1,DP p2,DP *pr) |
VL vl; |
|
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
MP m; |
MP m; |
DP s,t,u; |
DP s,t,u; |
|
|
l = l1; |
l = l1; |
} |
} |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void weyl_mulmd(vl,mod,p1,p2,pr) |
void weyl_mulmd(VL vl,int mod,DP p1,DP p2,DP *pr) |
VL vl; |
|
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
MP m; |
MP m; |
DP s,t,u; |
DP s,t,u; |
int i,l,l1; |
int i,l; |
static MP *w; |
static MP *w; |
static int wlen; |
static int wlen; |
|
|
|
|
else { |
else { |
for ( m = BDY(p2), l = 0; m; m = NEXT(m), l++ ); |
for ( m = BDY(p2), l = 0; m; m = NEXT(m), l++ ); |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void mulmdm(vl,mod,p,m0,pr) |
void mulmdm(VL vl,int mod,DP p,MP m0,DP *pr) |
VL vl; |
|
int mod; |
|
DP p; |
|
MP m0; |
|
DP *pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
P c; |
P c; |
|
|
} |
} |
} |
} |
|
|
void weyl_mulmdm(vl,mod,p,m0,pr) |
void weyl_mulmdm(VL vl,int mod,DP p,MP m0,DP *pr) |
VL vl; |
|
int mod; |
|
DP p; |
|
MP m0; |
|
DP *pr; |
|
{ |
{ |
DP r,t,t1; |
DP r,t,t1; |
MP m; |
MP m; |
|
|
else { |
else { |
for ( m = BDY(p), l = 0; m; m = NEXT(m), l++ ); |
for ( m = BDY(p), l = 0; m; m = NEXT(m), l++ ); |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
|
|
/* m0 = x0^d0*x1^d1*... * dx0^d(n/2)*dx1^d(n/2+1)*... */ |
/* m0 = x0^d0*x1^d1*... * dx0^d(n/2)*dx1^d(n/2+1)*... */ |
|
|
void weyl_mulmmm(vl,mod,m0,m1,n,pr) |
void weyl_mulmmm(VL vl,int mod,MP m0,MP m1,int n,DP *pr) |
VL vl; |
|
int mod; |
|
MP m0,m1; |
|
int n; |
|
DP *pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP mr,mr0; |
MQ mq; |
MQ mq; |
DP r,t,t1; |
DP r,t,t1; |
P c,c0,c1,cc; |
P c,c0,c1; |
DL d,d0,d1; |
DL d,d0,d1; |
int i,j,a,b,k,l,n2,s,min; |
int i,j,a,b,k,l,n2,s,min; |
static int *tab; |
static int *tab; |
|
|
for ( i = 0; i < n2; i++ ) { |
for ( i = 0; i < n2; i++ ) { |
a = d0->d[i]; b = d1->d[n2+i]; |
a = d0->d[i]; b = d1->d[n2+i]; |
k = d0->d[n2+i]; l = d1->d[i]; |
k = d0->d[n2+i]; l = d1->d[i]; |
|
|
/* degree of xi^a*(Di^k*xi^l)*Di^b */ |
/* degree of xi^a*(Di^k*xi^l)*Di^b */ |
s = a+k+l+b; |
a += l; |
|
b += k; |
|
s = MUL_WEIGHT(a,i)+MUL_WEIGHT(b,n2+i); |
|
|
/* compute xi^a*(Di^k*xi^l)*Di^b */ |
/* compute xi^a*(Di^k*xi^l)*Di^b */ |
min = MIN(k,l); |
min = MIN(k,l); |
|
|
if ( min+1 > tablen ) { |
if ( min+1 > tablen ) { |
if ( tab ) GC_free(tab); |
if ( tab ) GCFREE(tab); |
tab = (int *)MALLOC((min+1)*sizeof(int)); |
tab = (int *)MALLOC((min+1)*sizeof(int)); |
tablen = min+1; |
tablen = min+1; |
} |
} |
|
|
if ( n & 1 ) |
if ( n & 1 ) |
for ( mr0 = 0, j = 0; j <= min; j++ ) { |
for ( mr0 = 0, j = 0; j <= min; j++ ) { |
NEXTMP(mr0,mr); NEWDL(d,n); |
NEXTMP(mr0,mr); NEWDL(d,n); |
d->d[i] = l-j+a; d->d[n2+i] = k-j+b; |
d->d[i] = a-j; d->d[n2+i] = b-j; |
d->td = s; |
d->td = s; |
d->d[n-1] = s-(d->d[i]+d->d[n2+i]); |
d->d[n-1] = s-(MUL_WEIGHT(a-j,i)+MUL_WEIGHT(b-j,n2+i)); |
STOMQ(tab[j],mq); mr->c = (P)mq; mr->dl = d; |
STOMQ(tab[j],mq); mr->c = (P)mq; mr->dl = d; |
} |
} |
else |
else |
for ( mr0 = 0, s = 0, j = 0; j <= min; j++ ) { |
for ( mr0 = 0, s = 0, j = 0; j <= min; j++ ) { |
NEXTMP(mr0,mr); NEWDL(d,n); |
NEXTMP(mr0,mr); NEWDL(d,n); |
d->d[i] = l-j+a; d->d[n2+i] = k-j+b; |
d->d[i] = a-j; d->d[n2+i] = b-j; |
d->td = d->d[i]+d->d[n2+i]; /* XXX */ |
d->td = MUL_WEIGHT(a-j,i)+MUL_WEIGHT(b-j,n2+i); /* XXX */ |
s = MAX(s,d->td); /* XXX */ |
s = MAX(s,d->td); /* XXX */ |
STOMQ(tab[j],mq); mr->c = (P)mq; mr->dl = d; |
STOMQ(tab[j],mq); mr->c = (P)mq; mr->dl = d; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void mulmdc(vl,mod,p,c,pr) |
void mulmdc(VL vl,int mod,DP p,P c,DP *pr) |
VL vl; |
|
int mod; |
|
DP p; |
|
P c; |
|
DP *pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
int t; |
int t; |
|
|
} |
} |
} |
} |
|
|
void divsmdc(vl,mod,p,c,pr) |
void divsmdc(VL vl,int mod,DP p,P c,DP *pr) |
VL vl; |
|
int mod; |
|
DP p; |
|
P c; |
|
DP *pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
|
|
|
|
} |
} |
} |
} |
|
|
void _dtop_mod(vl,dvl,p,pr) |
void _dtop_mod(VL vl,VL dvl,DP p,P *pr) |
VL vl,dvl; |
|
DP p; |
|
P *pr; |
|
{ |
{ |
int n,i; |
int n,i; |
DL d; |
DL d; |
|
|
} |
} |
} |
} |
|
|
void _dp_mod(p,mod,subst,rp) |
void _dp_mod(DP p,int mod,NODE subst,DP *rp) |
DP p; |
|
int mod; |
|
NODE subst; |
|
DP *rp; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
P t,s; |
P t,s; |
|
|
} |
} |
} |
} |
|
|
void _dp_monic(p,mod,rp) |
void _dp_monic(DP p,int mod,DP *rp) |
DP p; |
|
int mod; |
|
DP *rp; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
int c,c1; |
int c,c1; |
NODE tn; |
|
|
|
if ( !p ) |
if ( !p ) |
*rp = 0; |
*rp = 0; |
|
|
} |
} |
} |
} |
|
|
void _printdp(d) |
void _printdp(DP d) |
DP d; |
|
{ |
{ |
int n,i; |
int n,i; |
MP m; |
MP m; |
|
|
|
|
/* merge p1 and p2 into pr */ |
/* merge p1 and p2 into pr */ |
|
|
void addmd_destructive(mod,p1,p2,pr) |
void addmd_destructive(int mod,DP p1,DP p2,DP *pr) |
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
int n; |
int n; |
MP m1,m2,mr,mr0,s; |
MP m1,m2,mr,mr0,s; |
|
|
} |
} |
} |
} |
|
|
void mulmd_dup(mod,p1,p2,pr) |
void mulmd_dup(int mod,DP p1,DP p2,DP *pr) |
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
if ( !do_weyl ) |
if ( !do_weyl ) |
comm_mulmd_dup(mod,p1,p2,pr); |
comm_mulmd_dup(mod,p1,p2,pr); |
|
|
weyl_mulmd_dup(mod,p1,p2,pr); |
weyl_mulmd_dup(mod,p1,p2,pr); |
} |
} |
|
|
void comm_mulmd_dup(mod,p1,p2,pr) |
void comm_mulmd_dup(int mod,DP p1,DP p2,DP *pr) |
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
MP m; |
MP m; |
DP s,t,u; |
DP s,t,u; |
|
|
l = l1; |
l = l1; |
} |
} |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void weyl_mulmd_dup(mod,p1,p2,pr) |
void weyl_mulmd_dup(int mod,DP p1,DP p2,DP *pr) |
int mod; |
|
DP p1,p2,*pr; |
|
{ |
{ |
MP m; |
MP m; |
DP s,t,u; |
DP s,t,u; |
int i,l,l1; |
int i,l; |
static MP *w; |
static MP *w; |
static int wlen; |
static int wlen; |
|
|
|
|
else { |
else { |
for ( m = BDY(p1), l = 0; m; m = NEXT(m), l++ ); |
for ( m = BDY(p1), l = 0; m; m = NEXT(m), l++ ); |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void mulmdm_dup(mod,p,m0,pr) |
void mulmdm_dup(int mod,DP p,MP m0,DP *pr) |
int mod; |
|
DP p; |
|
MP m0; |
|
DP *pr; |
|
{ |
{ |
MP m,mr,mr0; |
MP m,mr,mr0; |
DL d,dt,dm; |
DL d,dt,dm; |
int c,n,r,i; |
int c,n,i; |
int *pt,*p1,*p2; |
int *pt,*p1,*p2; |
|
|
if ( !p ) |
if ( !p ) |
|
|
} |
} |
} |
} |
|
|
void weyl_mulmdm_dup(mod,m0,p,pr) |
void weyl_mulmdm_dup(int mod,MP m0,DP p,DP *pr) |
int mod; |
|
MP m0; |
|
DP p; |
|
DP *pr; |
|
{ |
{ |
DP r,t,t1; |
DP r,t,t1; |
MP m; |
MP m; |
|
|
else { |
else { |
for ( m = BDY(p), l = 0; m; m = NEXT(m), l++ ); |
for ( m = BDY(p), l = 0; m; m = NEXT(m), l++ ); |
if ( l > wlen ) { |
if ( l > wlen ) { |
if ( w ) GC_free(w); |
if ( w ) GCFREE(w); |
w = (MP *)MALLOC(l*sizeof(MP)); |
w = (MP *)MALLOC(l*sizeof(MP)); |
wlen = l; |
wlen = l; |
} |
} |
|
|
for ( i = 0, tlen = 1; i < n2; i++ ) |
for ( i = 0, tlen = 1; i < n2; i++ ) |
tlen *= d0->d[n2+i]+1; |
tlen *= d0->d[n2+i]+1; |
if ( tlen > rtlen ) { |
if ( tlen > rtlen ) { |
if ( tab ) GC_free(tab); |
if ( tab ) GCFREE(tab); |
if ( psum ) GC_free(psum); |
if ( psum ) GCFREE(psum); |
rtlen = tlen; |
rtlen = tlen; |
tab = (struct cdlm *)MALLOC(rtlen*sizeof(struct cdlm)); |
tab = (struct cdlm *)MALLOC(rtlen*sizeof(struct cdlm)); |
psum = (MP *)MALLOC(rtlen*sizeof(MP)); |
psum = (MP *)MALLOC(rtlen*sizeof(MP)); |
|
|
|
|
/* m0 = x0^d0*x1^d1*... * dx0^d(n/2)*dx1^d(n/2+1)*... */ |
/* m0 = x0^d0*x1^d1*... * dx0^d(n/2)*dx1^d(n/2+1)*... */ |
|
|
void weyl_mulmmm_dup(mod,m0,m1,n,rtab,rtablen) |
void weyl_mulmmm_dup(int mod,MP m0,MP m1,int n,struct cdlm *rtab,int rtablen) |
int mod; |
|
MP m0,m1; |
|
int n; |
|
struct cdlm *rtab; |
|
int rtablen; |
|
{ |
{ |
MP m,mr,mr0; |
int c,c0,c1; |
DP r,t,t1; |
|
int c,c0,c1,cc; |
|
DL d,d0,d1,dt; |
DL d,d0,d1,dt; |
int i,j,a,b,k,l,n2,s,min,h,curlen; |
int i,j,a,b,k,l,n2,s,min,curlen; |
struct cdlm *p; |
struct cdlm *p; |
static int *ctab; |
static int *ctab; |
static struct cdlm *tab; |
static struct cdlm *tab; |
|
|
rtab[0].d = d; |
rtab[0].d = d; |
|
|
if ( rtablen > tmptablen ) { |
if ( rtablen > tmptablen ) { |
if ( tmptab ) GC_free(tmptab); |
if ( tmptab ) GCFREE(tmptab); |
tmptab = (struct cdlm *)MALLOC(rtablen*sizeof(struct cdlm)); |
tmptab = (struct cdlm *)MALLOC(rtablen*sizeof(struct cdlm)); |
tmptablen = rtablen; |
tmptablen = rtablen; |
} |
} |
|
|
for ( i = 0; i < n2; i++ ) { |
for ( i = 0; i < n2; i++ ) { |
a = d0->d[i]; b = d1->d[n2+i]; |
a = d0->d[i]; b = d1->d[n2+i]; |
k = d0->d[n2+i]; l = d1->d[i]; |
k = d0->d[n2+i]; l = d1->d[i]; |
|
|
|
/* degree of xi^a*(Di^k*xi^l)*Di^b */ |
|
a += l; |
|
b += k; |
|
s = MUL_WEIGHT(a,i)+MUL_WEIGHT(b,n2+i); |
|
|
if ( !k || !l ) { |
if ( !k || !l ) { |
a += l; |
|
b += k; |
|
s = a+b; |
|
for ( j = 0, p = rtab; j < curlen; j++, p++ ) { |
for ( j = 0, p = rtab; j < curlen; j++, p++ ) { |
if ( p->c ) { |
if ( p->c ) { |
dt = p->d; |
dt = p->d; |
|
|
continue; |
continue; |
} |
} |
if ( k+1 > tablen ) { |
if ( k+1 > tablen ) { |
if ( tab ) GC_free(tab); |
if ( tab ) GCFREE(tab); |
if ( ctab ) GC_free(ctab); |
if ( ctab ) GCFREE(ctab); |
tablen = k+1; |
tablen = k+1; |
tab = (struct cdlm *)MALLOC(tablen*sizeof(struct cdlm)); |
tab = (struct cdlm *)MALLOC(tablen*sizeof(struct cdlm)); |
ctab = (int *)MALLOC(tablen*sizeof(int)); |
ctab = (int *)MALLOC(tablen*sizeof(int)); |
} |
} |
/* degree of xi^a*(Di^k*xi^l)*Di^b */ |
|
s = a+k+l+b; |
|
/* compute xi^a*(Di^k*xi^l)*Di^b */ |
/* compute xi^a*(Di^k*xi^l)*Di^b */ |
min = MIN(k,l); |
min = MIN(k,l); |
mkwcm(k,l,mod,ctab); |
mkwcm(k,l,mod,ctab); |
|
|
if ( n & 1 ) |
if ( n & 1 ) |
for ( j = 0; j <= min; j++ ) { |
for ( j = 0; j <= min; j++ ) { |
NEWDL(d,n); |
NEWDL(d,n); |
d->d[i] = l-j+a; d->d[n2+i] = k-j+b; |
d->d[i] = a-j; d->d[n2+i] = b-j; |
d->td = s; |
d->td = s; |
d->d[n-1] = s-(d->d[i]+d->d[n2+i]); |
d->d[n-1] = s-(MUL_WEIGHT(a-j,i)+MUL_WEIGHT(b-j,n2+i)); |
tab[j].d = d; |
tab[j].d = d; |
tab[j].c = ctab[j]; |
tab[j].c = ctab[j]; |
} |
} |
else |
else |
for ( j = 0; j <= min; j++ ) { |
for ( j = 0; j <= min; j++ ) { |
NEWDL(d,n); |
NEWDL(d,n); |
d->d[i] = l-j+a; d->d[n2+i] = k-j+b; |
d->d[i] = a-j; d->d[n2+i] = b-j; |
d->td = d->d[i]+d->d[n2+i]; /* XXX */ |
d->td = MUL_WEIGHT(a-j,i)+MUL_WEIGHT(b-j,n2+i); /* XXX */ |
tab[j].d = d; |
tab[j].d = d; |
tab[j].c = ctab[j]; |
tab[j].c = ctab[j]; |
} |
} |
|
|
} |
} |
} |
} |
|
|
void comm_mulmd_tab_destructive(mod,nv,t,n,t1,n1) |
void comm_mulmd_tab_destructive(int mod,int nv,struct cdlm *t,int n,struct cdlm *t1,int n1) |
int mod; |
|
int nv; |
|
struct cdlm *t; |
|
int n; |
|
struct cdlm *t1; |
|
int n1; |
|
{ |
{ |
int i,j; |
int i,j; |
struct cdlm *p; |
struct cdlm *p; |
|
|
} |
} |
} |
} |
|
|
void adddl_dup(n,d1,d2,dr) |
void adddl_dup(int n,DL d1,DL d2,DL *dr) |
int n; |
|
DL d1,d2; |
|
DL *dr; |
|
{ |
{ |
DL dt; |
DL dt; |
int i; |
int i; |