| version 1.1, 2003/10/15 07:06:02 |
version 1.24, 2004/01/08 14:45:05 |
|
|
| #include<defs.h> |
|
| load("solve")$ |
load("solve")$ |
| |
load("gr")$ |
| |
|
| def nonposdegchk(Res){ |
#define EPS 1E-6 |
| |
#define TINY 1E-20 |
| |
#define MAX_ITER 100 |
| |
#define ROUND_THRESHOLD 0.4 |
| |
|
| for(I=0;I<length(Res);I++) |
def rotate(A,I,J,K,L,C,S){ |
| if(Res[I][1]<=0) |
|
| return 0$ |
|
| |
|
| return 1$ |
X=A[I][J]; |
| |
Y=A[K][L]; |
| |
A[I][J]=X*C-Y*S; |
| |
A[K][L]=X*S+Y*C; |
| |
|
| |
return 1; |
| } |
} |
| |
|
| def extmat(Mat,OneMat,N,M,I,J){ |
def jacobi(N,A,W){ |
| |
|
| if(J<N) |
S=OFFDIAG=0.0; |
| return Mat[I][J]$ |
|
| |
|
| if(OneMat[J][0]<=I && I<=OneMat[J][1]) |
for(J=0;J<N;J++){ |
| if(J==M-1) |
|
| return 1$ |
for(K=0;K<N;K++) |
| |
W[J][K]=0.0; |
| |
|
| |
W[J][J]=1.0; |
| |
S+=A[J][J]*A[J][J]; |
| |
|
| |
for(K=J+1;K<N;K++) |
| |
OFFDIAG+=A[J][K]*A[J][K]; |
| |
} |
| |
|
| |
TOLERANCE=EPS*EPS*(S/2+OFFDIAG); |
| |
|
| |
for(ITER=1;ITER<=MAX_ITER;ITER++){ |
| |
|
| |
OFFDIAG=0.0; |
| |
for(J=0;J<N-1;J++) |
| |
for(K=J+1;K<N;K++) |
| |
OFFDIAG+=A[J][K]*A[J][K]; |
| |
|
| |
if(OFFDIAG < TOLERANCE) |
| |
break; |
| |
|
| |
for(J=0;J<N-1;J++){ |
| |
for(K=J+1;K<N;K++){ |
| |
|
| |
if(dabs(A[J][K])<TINY) |
| |
continue; |
| |
|
| |
T=(A[K][K]-A[J][J])/(2.0*A[J][K]); |
| |
|
| |
if(T>=0.0) |
| |
T=1.0/(T+dsqrt(T*T+1)); |
| |
else |
| |
T=1.0/(T-dsqrt(T*T+1)); |
| |
|
| |
C=1.0/dsqrt(T*T+1); |
| |
|
| |
S=T*C; |
| |
|
| |
T*=A[J][K]; |
| |
|
| |
A[J][J]-=T; |
| |
A[K][K]+=T; |
| |
A[J][K]=0.0; |
| |
|
| |
for(I=0;I<J;I++) |
| |
rotate(A,I,J,I,K,C,S); |
| |
|
| |
for(I=J+1;I<K;I++) |
| |
rotate(A,J,I,I,K,C,S); |
| |
|
| |
for(I=K+1;I<N;I++) |
| |
rotate(A,J,I,K,I,C,S); |
| |
|
| |
for(I=0;I<N;I++) |
| |
rotate(W,J,I,K,I,C,S); |
| |
|
| |
} |
| |
} |
| |
} |
| |
|
| |
if (ITER > MAX_ITER) |
| |
return 0; |
| |
|
| |
for(I=0;I<N-1;I++){ |
| |
|
| |
K=I; |
| |
|
| |
T=A[K][K]; |
| |
|
| |
for(J=I+1;J<N;J++) |
| |
if(A[J][J]>T){ |
| |
K=J; |
| |
T=A[K][K]; |
| |
} |
| |
|
| |
A[K][K]=A[I][I]; |
| |
|
| |
A[I][I]=T; |
| |
|
| |
V=W[K]; |
| |
|
| |
W[K]=W[I]; |
| |
|
| |
W[I]=V; |
| |
} |
| |
|
| |
return 1; |
| |
} |
| |
|
| |
def interval2value(A,Vars){ |
| |
|
| |
B=atl(A)$ |
| |
|
| |
if(length(B)>2){ |
| |
print("bug")$ |
| |
return []$ |
| |
} |
| |
|
| |
if(length(B)==0){ |
| |
if(A) |
| |
return [Vars,1]$ |
| else |
else |
| return -1$ |
return []$ |
| |
} |
| |
else if(length(B)==1){ |
| |
|
| |
C=fargs(B[0])$ |
| |
D=vars(C)$ |
| |
E=solve(C,D)$ |
| |
|
| |
if(fop(B[0])==15) |
| |
return [Vars,E[0][1]+1]$ |
| |
else if(fop(B[0])==11) |
| |
return [Vars,E[0][1]-1]$ |
| |
else |
| |
return []$ |
| |
} |
| |
else{ |
| |
|
| |
C=fargs(B[0])$ |
| |
D=vars(C)$ |
| |
E=solve(C,D)$ |
| |
|
| |
C=fargs(B[1])$ |
| |
D=vars(C)$ |
| |
F=solve(C,D)$ |
| |
|
| |
return [Vars,(E[0][1]+F[0][1])/2]$ |
| |
} |
| |
|
| |
} |
| |
|
| |
def fixpointmain(F,Vars){ |
| |
|
| |
RET=[]$ |
| |
for(I=length(Vars)-1;I>=1;I--){ |
| |
|
| |
for(H=[],J=0;J<I;J++) |
| |
H=cons(Vars[J],H)$ |
| |
|
| |
G=interval2value(qe(ex(H,F)),Vars[I])$ |
| |
|
| |
if(G==[]) |
| |
return RET$ |
| |
else |
| |
RET=cons(G,RET)$ |
| |
|
| |
F=subf(F,G[0],G[1])$ |
| |
} |
| |
|
| |
G=interval2value(simpl(F),Vars[0])$ |
| |
|
| |
if(G==[]) |
| |
return RET$ |
| else |
else |
| return 0$ |
RET=cons(G,RET)$ |
| |
|
| |
return RET$ |
| } |
} |
| |
|
| def resvars(Res,Vars){ |
|
| |
|
| ResVars=newvect(length(Vars),Vars)$ |
def fixedpoint(A,FLAG){ |
| |
|
| for(I=0;I<length(Res);I++){ |
Vars=vars(A)$ |
| |
|
| |
N=length(A)$ |
| |
|
| |
if (FLAG==0) |
| |
for(F=@true,I=0;I < N; I++ ) { F = F @&& A[I] @> 0$ } |
| |
else if (FLAG==1) |
| |
for(F=@true,I=0;I < N; I++ ) { F = F @&& A[I] @< 0$ } |
| |
|
| |
return fixpointmain(F,Vars)$ |
| |
} |
| |
|
| |
def nonzerovec(A){ |
| |
|
| |
for(I=0;I<size(A)[0];I++) |
| |
if(A[I]!=0) |
| |
return 1$ |
| |
|
| |
return 0$ |
| |
} |
| |
|
| |
def junban(A,B){ |
| |
return (A<B ? 1:(A>B ? -1:0))$ |
| |
} |
| |
|
| |
def worder(A,B){ |
| |
return (A[0]<B[0] ? 1:(A[0]>B[0] ? -1:0))$ |
| |
} |
| |
|
| |
def bsort(A){ |
| |
|
| |
K=size(A)[0]-1$ |
| |
while(K>=0){ |
| |
J=-1$ |
| |
for(I=1;I<=K;I++) |
| |
if(A[I-1][0]<A[I][0]){ |
| |
J=I-1$ |
| |
X=A[J]$ |
| |
A[J]=A[I]$ |
| |
A[I]=X$ |
| |
} |
| |
K=J$ |
| |
} |
| |
return A$ |
| |
} |
| |
|
| |
def perm(I,P,TMP){ |
| |
|
| |
if(I>0){ |
| |
TMP=perm(I-1,P,TMP)$ |
| |
for(J=I-1;J>=0;J--){ |
| |
T=P[I]$ |
| |
P[I]=P[J]$ |
| |
P[J]=T$ |
| |
TMP=perm(I-1,P,TMP)$ |
| |
T=P[I]$ |
| |
P[I]=P[J]$ |
| |
P[J]=T$ |
| |
} |
| |
|
| |
return TMP$ |
| |
} |
| |
else{ |
| |
for(TMP0=[],K=0;K<size(P)[0];K++) |
| |
TMP0=cons(P[K],TMP0)$ |
| |
|
| |
TMP=cons(TMP0,TMP)$ |
| |
return TMP$ |
| |
} |
| |
} |
| |
|
| |
def marge(A,B){ |
| |
|
| |
RET=[]$ |
| |
for(I=0;I<length(A);I++) |
| |
for(J=0;J<length(B);J++) |
| |
RET=cons(append(A[I],B[J]),RET)$ |
| |
|
| |
return RET$ |
| |
} |
| |
|
| |
def wsort(A,B,C,FLAG,ID){ |
| |
|
| |
if(FLAG==0){ |
| |
D=newvect(length(B))$ |
| |
for(I=0;I<length(B);I++) |
| |
D[I]=[A[I],B[I],C[I]]$ |
| |
|
| |
D=bsort(D)$ |
| |
E=[]$ |
| |
for(I=0;I<length(B);I++) |
| |
E=cons(D[I][1],E)$ |
| |
E=reverse(E)$ |
| |
F=[]$ |
| |
for(I=0;I<length(B);I++) |
| |
F=cons(D[I][2],F)$ |
| |
F=reverse(F)$ |
| |
|
| for(J=0;J<size(ResVars)[0];J++) |
return [[ID,E,F]]$ |
| if(Res[I][0]==ResVars[J]) |
} |
| |
else{ |
| |
D=newvect(length(B))$ |
| |
for(I=0;I<length(B);I++) |
| |
D[I]=[A[I],B[I],C[I]]$ |
| |
|
| |
D=qsort(D,worder)$ |
| |
D0=[]$ |
| |
|
| |
for(I=0,J=0,TMP=[],X=0;I<size(D)[0];I++){ |
| |
if(X==D[I][0]) |
| |
TMP=cons(cdr(D[I]),TMP)$ |
| |
else{ |
| |
D0=cons(TMP,D0)$ |
| |
TMP=[]$ |
| |
TMP=cons(cdr(D[I]),TMP)$ |
| |
X=car(D[I])$ |
| |
} |
| |
} |
| |
D0=cdr(reverse(cons(TMP,D0)))$ |
| |
D0=map(ltov,D0)$ |
| |
for(I=0,TMP=[[]];I<length(D0);I++){ |
| |
TMP0=perm(length(D0[I])-1,D0[I],[])$ |
| |
TMP=marge(TMP,TMP0)$ |
| |
} |
| |
|
| |
RET=[]$ |
| |
for(I=0;I<length(TMP);I++){ |
| |
TMP0=[]$ |
| |
TMP1=[]$ |
| |
for(J=0;J<length(TMP[I]);J++){ |
| |
TMP0=cons(TMP[I][J][0],TMP0)$ |
| |
TMP1=cons(TMP[I][J][1],TMP1)$ |
| |
} |
| |
TMP0=reverse(TMP0)$ |
| |
TMP1=reverse(TMP1)$ |
| |
|
| |
RET=cons([ID,TMP0,TMP1],RET)$ |
| |
} |
| |
|
| |
return RET$ |
| |
} |
| |
} |
| |
|
| |
def nonposdegchk(Res){ |
| |
|
| |
for(I=0;I<length(Res);I++) |
| |
if(Res[I][1]<=0) |
| |
return 0$ |
| |
|
| |
return 1$ |
| |
} |
| |
|
| |
def getgcd(A,B){ |
| |
|
| |
VarsNumA=length(A)$ |
| |
VarsNumB=length(B)$ |
| |
|
| |
C=newvect(VarsNumB,B)$ |
| |
|
| |
for(I=0;I<VarsNumA;I++){ |
| |
|
| |
for(J=0;J<VarsNumB;J++) |
| |
if(B[J]==A[I][0]) |
| break$ |
break$ |
| |
|
| ResVars[J]=Res[I][1]$ |
if(J<VarsNumB) |
| |
C[J]=A[I][1]$ |
| } |
} |
| |
|
| return(ResVars)$ |
D=0$ |
| |
for(I=0;I<VarsNumB;I++) |
| |
D=gcd(D,C[I])$ |
| |
|
| |
if(D!=0){ |
| |
C=C/D$ |
| |
C=map(red,C)$ |
| |
} |
| |
|
| |
for(L=1,D=0,I=0;I<VarsNumB;I++){ |
| |
if(type(TMP=dn(C[I]))==1) |
| |
L=ilcm(L,TMP)$ |
| |
|
| |
if(type(TMP=nm(C[I]))==1) |
| |
D=igcd(D,TMP)$ |
| |
} |
| |
|
| |
C=C*L$ |
| |
if(D!=0) |
| |
C=C/D$ |
| |
|
| |
RET=[]$ |
| |
for(I=0;I<VarsNumB;I++) |
| |
RET=cons([B[I],C[I]],RET)$ |
| |
|
| |
return RET$ |
| } |
} |
| |
|
| def makeret(Res,Vars,B){ |
def makeret(Res,Vars,FLAG){ |
| |
|
| |
ResNum=length(Res)$ |
| VarsNum=length(Vars)$ |
VarsNum=length(Vars)$ |
| |
|
| ResMat=newvect(VarsNum)$ |
ResVec=newvect(ResNum)$ |
| for(I=0;I<VarsNum;I++) |
|
| ResMat[I]=newvect(2)$ |
|
| |
|
| for(I=0;I<VarsNum;I++){ |
for(M=0,I=0;I<ResNum;I++){ |
| ResMat[I][0]=Vars[I]$ |
if(member(Res[I][0],Vars)){ |
| ResMat[I][1]=Vars[I]$ |
ResVec[I]=Res[I][1]$ |
| } |
|
| |
|
| for(I=0;I<length(Res);I++){ |
|
| |
|
| for(J=0;J<size(ResMat)[0];J++) |
if(FLAG && type(ResVec[I])==1){ |
| if(Res[I][0]==ResMat[J][0]) |
if(M==0) |
| |
M=ResVec[I]$ |
| |
else |
| |
if(ResVec[I]<M) |
| |
M=ResVec[I]$ |
| |
} |
| |
} |
| |
} |
| |
|
| |
if(M!=0) |
| |
ResVec=ResVec/M; |
| |
|
| |
RET=newvect(VarsNum,Vars)$ |
| |
|
| |
for(I=0;I<ResNum;I++){ |
| |
for(J=0;J<VarsNum;J++) |
| |
if(Vars[J]==Res[I][0]) |
| break$ |
break$ |
| |
|
| if(J<VarsNum) |
if(J<VarsNum) |
| ResMat[J][1]=Res[I][1]*B$ |
RET[J]=ResVec[I]$ |
| } |
} |
| |
|
| |
|
| |
for(J=0;J<length(Vars);J++) |
| |
RET=map(subst,RET,Vars[J], |
| |
strtov(rtostr(Vars[J])+"_deg"))$ |
| |
|
| for(I=0;I<VarsNum;I++) |
for(I=0;I<VarsNum;I++) |
| for(J=0;J<length(Vars);J++) |
if(type(RET[I])!=1) |
| ResMat[I][1]=subst(ResMat[I][1],Vars[J], |
return [1,RET]$ |
| strtov(rtostr(Vars[J])+"_deg"))$ |
|
| |
|
| ResMat=map(vtol,ResMat)$ |
return [0,RET]$ |
| return(vtol(ResMat))$ |
} |
| |
|
| |
def roundret(V){ |
| |
|
| |
VN=size(V)[0]$ |
| |
|
| |
RET0=V$ |
| |
for(I=1;I<1000;I++){ |
| |
RET1=I*RET0$ |
| |
for(J=0;J<VN;J++){ |
| |
X=drint(RET1[J])$ |
| |
if(dabs(X-RET1[J])<ROUND_THRESHOLD) |
| |
RET1[J]=X$ |
| |
else |
| |
break$ |
| |
} |
| |
if(J==VN) |
| |
break$ |
| |
} |
| |
|
| |
if(I==1000) |
| |
return []$ |
| |
else |
| |
return RET1$ |
| } |
} |
| |
|
| def afo(A,B){ |
def chkou(L,ExpMat,CHAGORD){ |
| |
|
| for(I=0;I<size(A)[0];I++){ |
for(P=1,I=0;I<L;I++){ |
| if(A[I]<B[I]) |
Q=ExpMat[L][CHAGORD[I]]$ |
| return 1$ |
for(J=0;J<size(ExpMat[0])[0];J++){ |
| |
ExpMat[L][CHAGORD[J]]=red((ExpMat[I][CHAGORD[I]] |
| if(A[I]>B[I]) |
*ExpMat[L][CHAGORD[J]]- |
| return -1$ |
Q*ExpMat[I][CHAGORD[J]])/P)$ |
| |
} |
| |
|
| |
P=ExpMat[I][CHAGORD[I]]$ |
| } |
} |
| |
|
| return 0$ |
for(J=0;J<size(ExpMat[0])[0];J++) |
| |
if(ExpMat[L][CHAGORD[J]]!=0) |
| |
break$ |
| |
|
| |
if(J==size(ExpMat[0])[0]) |
| |
return L$ |
| |
else{ |
| |
TMP=CHAGORD[L]$ |
| |
CHAGORD[L]=CHAGORD[J]$ |
| |
CHAGORD[J]=TMP$ |
| |
return (L+1)$ |
| |
} |
| } |
} |
| |
|
| def weight(PolyList,Vars){ |
def qcheckmain(PolyList,Vars){ |
| |
|
| dp_ord(2)$ |
RET=[]$ |
| |
PolyListNum=length(PolyList)$ |
| |
VarsNum=length(Vars)$ |
| |
|
| |
ExpMat=newvect(VarsNum)$ |
| |
CHAGORD=newvect(VarsNum)$ |
| |
for(I=0;I<VarsNum;I++) |
| |
CHAGORD[I]=I$ |
| |
|
| |
L=0$ |
| |
for(I=0;I<PolyListNum;I++){ |
| |
Poly=dp_ptod(PolyList[I],Vars)$ |
| |
BASE0=dp_etov(dp_ht(Poly))$ |
| |
Poly=dp_rest(Poly)$ |
| |
for(;Poly!=0;Poly=dp_rest(Poly)){ |
| |
ExpMat[L]=dp_etov(dp_ht(Poly))-BASE0$ |
| |
L=chkou(L,ExpMat,CHAGORD)$ |
| |
if(L==VarsNum-1) |
| |
return [L,CHAGORD,ExpMat]$ |
| |
} |
| |
} |
| |
|
| |
return [L,CHAGORD,ExpMat]$ |
| |
} |
| |
|
| |
def inner(A,B){ |
| |
|
| |
SUM=0$ |
| |
for(I=0;I<size(A)[0];I++) |
| |
SUM+=A[I]*B[I]$ |
| |
|
| |
return SUM$ |
| |
} |
| |
|
| |
def checktd(PolyList,Vars,ResVars){ |
| |
|
| PolyListNum=length(PolyList)$ |
PolyListNum=length(PolyList)$ |
| |
VarsNum=length(Vars)$ |
| |
|
| ExpMat=[]$ |
L=0$ |
| for(I=0;I<PolyListNum;I++) |
for(I=0;I<PolyListNum;I++){ |
| for(Poly=dp_ptod(PolyList[I],Vars);Poly!=0;Poly=dp_rest(Poly)) |
Poly=dp_ptod(PolyList[I],Vars)$ |
| ExpMat=cons(dp_etov(dp_ht(Poly)),ExpMat)$ |
J0=inner(dp_etov(dp_ht(Poly)),ResVars)$ |
| |
Poly=dp_rest(Poly)$ |
| |
for(;Poly!=0;Poly=dp_rest(Poly)) |
| |
if(J0!=inner(dp_etov(dp_ht(Poly)),ResVars)) |
| |
return 0$ |
| |
} |
| |
|
| |
return 1$ |
| |
} |
| |
|
| ExpMat=reverse(ExpMat)$ |
def value2(Vars,Ans){ |
| ExpMat=newvect(length(ExpMat),ExpMat)$ |
|
| |
|
| ExpMatRowNum=size(ExpMat)[0]$ |
N=length(Vars)$ |
| ExpMatColNum=size(ExpMat[0])[0]$ |
Res=newvect(N)$ |
| ExtMatRowNum=ExpMatRowNum$ |
for(I=0;I<N;I++){ |
| ExtMatColNum=ExpMatColNum+PolyListNum$ |
Res[I]=newvect(2)$ |
| |
Res[I][0]=Vars[I]$ |
| |
Res[I][1]=Ans[I]$ |
| |
} |
| |
|
| OneMat=newmat(ExtMatColNum,2)$ |
Res=getgcd(Res,Vars)$ |
| |
|
| for(I=0;I<ExpMatColNum;I++){ |
if(nonposdegchk(Res)){ |
| OneMat[I][0]=0$ |
TMP1=makeret(Res,Vars,1)$ |
| OneMat[I][1]=ExtMatRowNum-1$ |
return vtol(TMP1[1])$ |
| } |
} |
| |
else |
| |
return []$ |
| |
} |
| |
|
| for(I=ExpMatColNum,SUM=0;I<ExtMatColNum;I++){ |
def qcheck(PolyList,Vars,FLAG){ |
| OneMat[I][0]=SUM$ |
|
| SUM=SUM+nmono(PolyList[I-ExpMatColNum])$ |
RET=[]$ |
| OneMat[I][1]=SUM-1$ |
Res=qcheckmain(PolyList,Vars)$ |
| |
VarsNum=length(Vars)$ |
| |
|
| |
IndNum=Res[0]$ |
| |
CHAGORD=Res[1]$ |
| |
ExpMat=Res[2]$ |
| |
|
| |
SolveList=[]$ |
| |
for(I=0;I<IndNum;I++){ |
| |
TMP=0$ |
| |
for(J=0;J<VarsNum;J++) |
| |
TMP+=ExpMat[I][CHAGORD[J]]*Vars[CHAGORD[J]]$ |
| |
|
| |
SolveList=cons(TMP,SolveList)$ |
| } |
} |
| |
|
| NormMat=newmat(ExtMatColNum-1,ExtMatColNum)$ |
Rea=vars(SolveList)$ |
| |
|
| for(I=0;I<ExtMatColNum-1;I++) |
VarsList=[]$ |
| for(J=0;J<ExtMatColNum-1;J++){ |
for(I=0;I<VarsNum;I++) |
| ST=MAX(OneMat[I][0],OneMat[J][0])$ |
if(member(Vars[CHAGORD[I]],Rea)) |
| ED=MIN(OneMat[I][1],OneMat[J][1])$ |
VarsList=cons(Vars[CHAGORD[I]],VarsList)$ |
| if(ST>ED) |
|
| continue$ |
Res=solve(reverse(SolveList),reverse(VarsList))$ |
| for(K=ST;K<=ED;K++){ |
Res=getgcd(Res,Rea)$ |
| NormMat[I][J]=NormMat[I][J]+ |
|
| extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,K,I)* |
if(nonposdegchk(Res)){ |
| extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,K,J)$ |
|
| |
ResVars=makeret(Res,Vars,0)$ |
| |
|
| |
if(checktd(PolyList,Vars,ResVars[1])==1){ |
| |
if(ResVars[0]==0){ |
| |
RET=append(RET,wsort(ResVars[1],Vars, |
| |
ResVars[1],FLAG,0))$ |
| |
|
| |
return RET$ |
| } |
} |
| } |
else{ |
| |
|
| for(I=0;I<ExtMatColNum-1;I++){ |
TMP=vtol(ResVars[1])$ |
| ST=MAX(OneMat[I][0],OneMat[ExtMatColNum-1][0])$ |
|
| ED=MIN(OneMat[I][1],OneMat[ExtMatColNum-1][1])$ |
|
| if(ST>ED) |
|
| continue$ |
|
| |
|
| for(K=ST;K<=ED;K++){ |
/* |
| NormMat[I][ExtMatColNum-1]=NormMat[I][ExtMatColNum-1]+ |
RET=append(RET,[[0,Vars,TMP]])$ |
| extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,K,I)* |
*/ |
| extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,K,ExtMatColNum-1)$ |
|
| |
if((TMP0=fixedpoint(TMP,0))!=[]){ |
| |
|
| |
for(I=0;I<length(TMP0);I++) |
| |
TMP=map(subst,TMP,TMP0[I][0], |
| |
TMP0[I][1])$ |
| |
|
| |
TMP=value2(Vars,TMP)$ |
| |
|
| |
if(TMP!=[]) |
| |
RET=append(RET,wsort(TMP,Vars, |
| |
TMP,FLAG,1/10))$ |
| |
} |
| |
else if((TMP0=fixedpoint(TMP,1))!=[]){ |
| |
|
| |
for(I=0;I<length(TMP0);I++) |
| |
TMP=map(subst,TMP,TMP0[I][0], |
| |
TMP0[I][1])$ |
| |
|
| |
TMP=value2(Vars,TMP)$ |
| |
|
| |
if(TMP!=[]) |
| |
RET=append(RET,wsort(TMP,Vars, |
| |
TMP,FLAG,1/10))$ |
| |
} |
| |
|
| |
return RET$ |
| |
} |
| } |
} |
| |
else |
| |
return []$ |
| } |
} |
| |
else |
| |
return []$ |
| |
|
| ExtVars=Vars$ |
} |
| for(I=0;I<PolyListNum-1;I++) |
|
| ExtVars=append(ExtVars,[uc()])$ |
|
| |
|
| |
def leastsq(NormMat,ExpMat,Vars,FLAG,ID){ |
| |
|
| |
RET=[]$ |
| |
|
| |
ExpMatRowNum=size(ExpMat)[0]$ |
| |
ExpMatColNum=size(ExpMat[0])[0]$ |
| |
|
| |
if(NormMat==0){ |
| |
NormMat=newmat(ExpMatColNum,ExpMatColNum)$ |
| |
|
| |
for(I=0;I<ExpMatColNum;I++) |
| |
for(J=I;J<ExpMatColNum;J++) |
| |
for(K=0;K<ExpMatRowNum;K++) |
| |
NormMat[I][J]+= |
| |
ExpMat[K][I]*ExpMat[K][J]$ |
| |
} |
| |
|
| |
BVec=newvect(ExpMatColNum)$ |
| |
|
| |
for(I=0;I<ExpMatColNum;I++) |
| |
for(J=0;J<ExpMatRowNum;J++) |
| |
BVec[I]+=ExpMat[J][I]$ |
| |
|
| SolveList=[]$ |
SolveList=[]$ |
| for(I=0;I<ExtMatColNum-1;I++){ |
for(I=0;I<ExpMatColNum;I++){ |
| TMP=0$ |
TMP=0$ |
| for(J=0;J<ExtMatColNum-1;J++) |
for(J=0;J<I;J++) |
| TMP=TMP+NormMat[I][J]*ExtVars[J]$ |
TMP+=NormMat[J][I]*Vars[J]$ |
| |
|
| TMP=TMP-NormMat[I][ExtMatColNum-1]$ |
for(J=I;J<ExpMatColNum;J++) |
| |
TMP+=NormMat[I][J]*Vars[J]$ |
| |
|
| |
TMP-=BVec[I]$ |
| SolveList=cons(TMP,SolveList)$ |
SolveList=cons(TMP,SolveList)$ |
| } |
} |
| |
|
| ReaVars=vars(SolveList)$ |
Rea=vars(SolveList)$ |
| Res=solve(SolveList,reverse(ExtVars))$ |
|
| |
|
| |
VarsList=[]$ |
| |
for(I=0;I<length(Vars);I++) |
| |
if(member(Vars[I],Rea)) |
| |
VarsList=cons(Vars[I],VarsList)$ |
| |
|
| |
Res=solve(SolveList,VarsList)$ |
| |
Res=getgcd(Res,Rea)$ |
| |
|
| if(nonposdegchk(Res)){ |
if(nonposdegchk(Res)){ |
| |
|
| ResVars=resvars(Res,ExtVars)$ |
TMP1=makeret(Res,Vars,1)$ |
| |
|
| for(I=0;I<ExtMatRowNum;I++){ |
if(TMP1[0]==0){ |
| TMP=0$ |
|
| for(J=0;J<ExtMatColNum-1;J++) |
TMP=roundret(TMP1[1])$ |
| if((K=extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,I,J))!=0) |
|
| TMP=TMP+K*ResVars[J]$ |
RET=append(RET,wsort(TMP1[1],Vars, |
| |
map(drint,TMP1[1]*1.0),FLAG,ID))$ |
| if(TMP!=extmat(ExpMat,OneMat,ExpMatColNum,ExtMatColNum,I,ExtMatColNum-1)) |
|
| break$ |
if(TMP!=[]) |
| |
RET=append(RET,wsort(TMP1[1],Vars, |
| |
TMP,FLAG,ID+1))$ |
| |
|
| |
return RET$ |
| } |
} |
| |
else{ |
| |
|
| if(I==ExtMatRowNum){ |
TMP=vtol(TMP1[1])$ |
| print("complitely homogenized")$ |
|
| return(makeret(Res,Vars,1))$ |
/* |
| |
RET=append(RET,[[ID,Vars,vtol(TMP1[1])]])$ |
| |
*/ |
| |
|
| |
if((TMP0=fixedpoint(TMP1[1],0))!=[]){ |
| |
|
| |
for(I=0;I<length(TMP0);I++) |
| |
TMP=map(subst,TMP,TMP0[I][0],TMP0[I][1])$ |
| |
|
| |
TMP=value2(Vars,TMP)$ |
| |
|
| |
if(TMP!=[]) |
| |
RET=append(RET, |
| |
wsort(TMP,Vars,TMP,FLAG,ID+1/10))$ |
| |
|
| |
} |
| |
else if((TMP0=fixedpoint(TMP1[1],1))!=[]){ |
| |
|
| |
for(I=0;I<length(TMP0);I++) |
| |
TMP=map(subst,TMP,TMP0[I][0],TMP0[I][1])$ |
| |
|
| |
TMP=value2(Vars,TMP)$ |
| |
|
| |
if(TMP!=[]) |
| |
RET=append(RET, |
| |
wsort(TMP,Vars,TMP,FLAG,ID+1/10))$ |
| |
} |
| |
|
| |
return RET$ |
| } |
} |
| else |
|
| print(makeret(Res,Vars,1.0))$ |
|
| } |
} |
| |
else |
| |
return RET$ |
| |
|
| ExpMat=qsort(ExpMat,afo)$ |
} |
| ExpMat2=[]$ |
|
| for(I=0;I<size(ExpMat)[0];I++) |
|
| if(car(ExpMat2)!=ExpMat[I]) |
|
| ExpMat2=cons(ExpMat[I],ExpMat2)$ |
|
| |
|
| ExpMat=newvect(length(ExpMat2),ExpMat2)$ |
def unitweight(ExpMat,Vars,PolyListNum,OneMat,FLAG){ |
| |
|
| |
RET=[]$ |
| |
|
| ExpMatRowNum=size(ExpMat)[0]$ |
ExpMatRowNum=size(ExpMat)[0]$ |
| ExpMatColNum=size(ExpMat[0])[0]$ |
ExpMatColNum=size(ExpMat[0])[0]$ |
| |
ExtMatColNum=ExpMatColNum+PolyListNum$ |
| |
|
| NormMat=newmat(ExpMatColNum,ExpMatColNum+1)$ |
ExtVars=reverse(Vars)$ |
| |
for(I=0;I<PolyListNum;I++) |
| |
ExtVars=cons(uc(),ExtVars)$ |
| |
|
| |
ExtVars=reverse(ExtVars)$ |
| |
|
| |
NormMat0=newvect(ExpMatColNum)$ |
| for(I=0;I<ExpMatColNum;I++) |
for(I=0;I<ExpMatColNum;I++) |
| for(J=0;J<ExpMatColNum;J++) |
NormMat0[I]=newvect(ExpMatColNum)$ |
| |
|
| |
for(I=0;I<ExpMatColNum;I++) |
| |
for(J=I;J<ExpMatColNum;J++) |
| for(K=0;K<ExpMatRowNum;K++) |
for(K=0;K<ExpMatRowNum;K++) |
| NormMat[I][J]=NormMat[I][J]+ExpMat[K][I]*ExpMat[K][J]$ |
NormMat0[I][J]+= |
| |
ExpMat[K][I]* |
| |
ExpMat[K][J]$ |
| |
|
| |
NormMat1=newvect(ExtMatColNum)$ |
| |
for(I=0;I<ExtMatColNum;I++) |
| |
NormMat1[I]=newvect(ExtMatColNum)$ |
| |
|
| |
|
| |
WorkMat=newvect(ExtMatColNum)$ |
| |
for(I=0;I<ExtMatColNum;I++) |
| |
WorkMat[I]=newvect(ExtMatColNum)$ |
| |
|
| |
|
| for(I=0;I<ExpMatColNum;I++) |
for(I=0;I<ExpMatColNum;I++) |
| for(K=0;K<ExpMatRowNum;K++) |
for(J=I;J<ExpMatColNum;J++) |
| NormMat[I][ExpMatColNum]=NormMat[I][ExpMatColNum]+ExpMat[K][I]$ |
NormMat1[I][J]=NormMat0[I][J]$ |
| |
|
| SolveList=[]$ |
for(I=0;I<ExpMatColNum;I++) |
| for(I=0;I<ExpMatColNum;I++){ |
for(J=0;J<PolyListNum;J++) |
| TMP=0$ |
for(K=OneMat[J];K<OneMat[J+1];K++) |
| for(J=0;J<ExpMatColNum;J++) |
NormMat1[I][J+ExpMatColNum]-= |
| TMP=TMP+NormMat[I][J]*Vars[J]$ |
ExpMat[K][I]$ |
| |
|
| TMP=TMP-NormMat[I][ExpMatColNum]$ |
for(I=0;I<PolyListNum;I++) |
| SolveList=cons(TMP,SolveList)$ |
NormMat1[I+ExpMatColNum][I+ExpMatColNum]=OneMat[I+1]-OneMat[I]$ |
| } |
|
| |
|
| Res=solve(SolveList,Vars)$ |
if(jacobi(ExtMatColNum,NormMat1,WorkMat)){ |
| if(nonposdegchk(Res)) |
|
| return(makeret(Res,Vars,1.0))$ |
|
| |
|
| Ret=[]$ |
Res=newvect(ExpMatColNum)$ |
| |
for(I=0;I<ExpMatColNum;I++){ |
| |
Res[I]=newvect(2)$ |
| |
Res[I][0]=Vars[I]$ |
| |
Res[I][1]=WorkMat[ExtMatColNum-1][I]$ |
| |
} |
| |
|
| |
if(nonposdegchk(Res)){ |
| |
|
| |
TMP1=makeret(Res,Vars,1)$ |
| |
|
| |
TMP=roundret(TMP1[1])$ |
| |
|
| |
RET=append(RET,wsort(TMP1[1],Vars, |
| |
map(drint,TMP1[1]*1.0),FLAG,1))$ |
| |
|
| |
if(TMP!=[]) |
| |
RET=append(RET,wsort(TMP1[1],Vars, |
| |
TMP,FLAG,2))$ |
| |
} |
| |
|
| |
} |
| |
|
| |
return [NormMat0,RET]$ |
| |
} |
| |
|
| |
def weight(PolyList,Vars,FLAG){ |
| |
|
| |
Vars0=vars(PolyList)$ |
| |
Vars1=[]$ |
| for(I=0;I<length(Vars);I++) |
for(I=0;I<length(Vars);I++) |
| Ret=cons([Vars[I],1.0],Ret)$ |
if(member(Vars[I],Vars0)) |
| |
Vars1=cons(Vars[I],Vars1)$ |
| |
|
| return reverse(Ret)$ |
Vars=reverse(Vars1)$ |
| |
|
| |
RET=[]$ |
| |
|
| |
TMP=qcheck(PolyList,Vars,FLAG)$ |
| |
|
| |
if(TMP!=[]){ |
| |
RET=append(RET,TMP)$ |
| |
return RET$ |
| |
} |
| |
|
| |
dp_ord(2)$ |
| |
|
| |
PolyListNum=length(PolyList)$ |
| |
|
| |
OneMat=newvect(PolyListNum+1,[0])$ |
| |
ExpMat=[]$ |
| |
for(I=0;I<PolyListNum;I++){ |
| |
for(Poly=dp_ptod(PolyList[I],Vars); |
| |
Poly!=0;Poly=dp_rest(Poly)){ |
| |
ExpMat=cons(dp_etov(dp_ht(Poly)),ExpMat)$ |
| |
} |
| |
OneMat[I+1]=length(ExpMat)$ |
| |
} |
| |
|
| |
ExpMat=reverse(ExpMat)$ |
| |
ExpMat=newvect(length(ExpMat),ExpMat)$ |
| |
|
| |
TMP=unitweight(ExpMat,Vars,PolyListNum,OneMat,FLAG)$ |
| |
|
| |
RET=append(RET,TMP[1])$ |
| |
|
| |
TMP0=leastsq(TMP[0],ExpMat,Vars,FLAG,3)$ |
| |
|
| |
RET=append(RET,TMP0)$ |
| |
|
| |
ExpMat=qsort(ExpMat,junban)$ |
| |
|
| |
ExpMat2=[]$ |
| |
for(I=0;I<size(ExpMat)[0];I++) |
| |
if(car(ExpMat2)!=ExpMat[I]) |
| |
ExpMat2=cons(ExpMat[I],ExpMat2)$ |
| |
|
| |
if(size(ExpMat)[0]!=length(ExpMat2)){ |
| |
ExpMat=newvect(length(ExpMat2),ExpMat2)$ |
| |
RET=append(RET,leastsq(0,ExpMat,Vars,FLAG,5))$ |
| |
} |
| |
else{ |
| |
TMP0=map(ltov,TMP0)$ |
| |
|
| |
for(I=0;I<length(TMP0);I++) |
| |
if(TMP0[I][0]==3) |
| |
TMP0[I][0]=5$ |
| |
else if(TMP0[I][0]==4) |
| |
TMP0[I][0]=6$ |
| |
|
| |
TMP0=map(vtol,TMP0)$ |
| |
|
| |
RET=append(RET,TMP0)$ |
| |
} |
| |
|
| |
return RET$ |
| } |
} |
| |
|
| end$ |
end$ |
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to weight CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / lib