[BACK]Return to new_pd.rr CVS log [TXT][DIR] Up to [local] / OpenXM / src / asir-contrib / testing / noro

Diff for /OpenXM/src/asir-contrib/testing/noro/Attic/new_pd.rr between version 1.4 and 1.8

version 1.4, 2011/02/18 02:59:04 version 1.8, 2011/11/01 00:35:56
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir-contrib/testing/noro/new_pd.rr,v 1.3 2011/01/19 04:52:03 noro Exp $ */  /* $OpenXM: OpenXM/src/asir-contrib/testing/noro/new_pd.rr,v 1.7 2011/08/09 07:49:38 noro Exp $ */
 import("gr")$  import("gr")$
 module noro_pd$  module noro_pd$
 static GBCheck,F4,EProcs,Procs,SatHomo,GBRat$  static GBCheck,F4,EProcs,Procs,SatHomo,GBRat,SuccSat,RepColon$
   
   localf radical_membership_sat$
 localf witness$  localf witness$
 localf get_lc,tomonic,aa,ideal_intersection_m,redbase$  localf get_lc,tomonic,aa,ideal_intersection_m,redbase$
 localf para_exec,nd_gr_rat,competitive_exec,call_func$  localf para_exec,nd_gr_rat,competitive_exec,call_func,call_func_serial$
 localf call_ideal_list_intersection$  localf call_ideal_list_intersection$
 localf call_colon,call_prime_dec$  localf call_colon,call_prime_dec$
   localf prime_dec2, prime_dec_main2$
 localf first_second$  localf first_second$
 localf third$  localf third$
 localf locsat,iso_comp_para,extract_qj,colon_prime_dec,extract_comp$  localf locsat,iso_comp_para,extract_qj,colon_prime_dec,extract_comp$
Line 17  localf prepost$
Line 19  localf prepost$
 localf monodec0,monodec,prod$  localf monodec0,monodec,prod$
 localf extract_qd,primary_check$  localf extract_qd,primary_check$
 localf second$  localf second$
 localf gbrat,comp_third_tdeg,comp_tord$  localf gbrat,succsat,repcolon,comp_third_tdeg,comp_tord$
 localf power$  localf power$
   
 localf syci_dec, syc_dec$  localf syci_dec, syc_dec$
Line 35  localf complete_qdecomp, partial_qdecomp, partial_qdec
Line 37  localf complete_qdecomp, partial_qdecomp, partial_qdec
 localf partial_decomp, partial_decomp0, zprimacomp, zprimecomp$  localf partial_decomp, partial_decomp0, zprimacomp, zprimecomp$
 localf fast_gb, incremental_gb, elim_gb, ldim, make_mod_subst$  localf fast_gb, incremental_gb, elim_gb, ldim, make_mod_subst$
 localf rsgn, find_npos, gen_minipoly, indepset$  localf rsgn, find_npos, gen_minipoly, indepset$
 localf maxindep, contraction, ideal_list_intersection, ideal_intersection$  localf maxindep, maxindep2, contraction, contraction_m, ideal_list_intersection, ideal_intersection$
 localf radical_membership, modular_radical_membership$  localf radical_membership, modular_radical_membership$
 localf radical_membership_rep, ideal_product, saturation$  localf radical_membership_rep, ideal_product, saturation$
 localf sat, satind, sat_ind, colon, isat$  localf sat, satind, sat_ind, colon, isat$
 localf ideal_colon, ideal_sat, ideal_inclusion, qd_simp_comp, qd_remove_redundant_comp$  localf ideal_colon, ideal_sat, ideal_inclusion, qd_simp_comp, qd_remove_redundant_comp$
 localf pd_simp_comp$  localf pd_simp_comp, remove_identical_comp$
 localf pd_remove_redundant_comp, ppart, sq, gen_fctr, gen_nf, gen_gb_comp$  localf pd_remove_redundant_comp, ppart, sq, gen_fctr, gen_nf, gen_gb_comp$
 localf gen_mptop, lcfactor, compute_deg0, compute_deg, member$  localf gen_mptop, lcfactor, compute_deg0, compute_deg, member$
 localf elimination, setintersection, setminus, sep_list$  localf elimination, setintersection, setminus, sep_list$
Line 50  localf gbcheck,f4,sathomo,qd_check,qdb_check$
Line 52  localf gbcheck,f4,sathomo,qd_check,qdb_check$
 SatHomo=0$  SatHomo=0$
 GBCheck=1$  GBCheck=1$
 GBRat=0$  GBRat=0$
   SuccSat=0$
   RepColon=0$
   
 #define MAX(a,b) ((a)>(b)?(a):(b))  #define MAX(a,b) ((a)>(b)?(a):(b))
 #define ACCUM_TIME(C,R) {T1 = time(); C += (T1[0]-T0[0])+(T1[1]-T0[1]); R += (T1[3]-T0[3]); }  #define ACCUM_TIME(C,R) {T1 = time(); C += (T1[0]-T0[0])+(T1[1]-T0[1]); R += (T1[3]-T0[3]); }
   
 def gbrat(A)  def gbrat(A)
 {  {
         if ( A ) GBRat = 1;          GBRat = A;
         else GBRat = 0;  
 }  }
   
   def succsat(A)
   {
           SuccSat = A;
   }
   
   def repcolon(A)
   {
           RepColon = A;
   }
   
 def gbcheck(A)  def gbcheck(A)
 {  {
         if ( A ) GBCheck = 1;          if ( A ) GBCheck = 1;
Line 165  def qdb_check(B,V,QD)
Line 178  def qdb_check(B,V,QD)
         for ( I = 0, Q = [1]; I < N; I++ )          for ( I = 0, Q = [1]; I < N; I++ )
                 for ( J = 0, QL = map(first,QD[I]), L = length(QL);                  for ( J = 0, QL = map(first,QD[I]), L = length(QL);
                         J < L; J++ )                          J < L; J++ )
                         Q = ideal_intersection(Q,QL[J],V,0|mod=Mod);                          Q = ideal_intersection_m(Q,QL[J],V,0|mod=Mod);
           Q = nd_gr(Q,V,0,0);
         if ( !gen_gb_comp(G,Q,Mod) )          if ( !gen_gb_comp(G,Q,Mod) )
                 return 0;                  return 0;
         for ( I = 0; I < N; I++ ) {          for ( I = 0; I < N; I++ ) {
Line 273  def syci_dec(B,V)
Line 287  def syci_dec(B,V)
         if ( type(Ass=getopt(ass)) == -1 ) Ass = 0;          if ( type(Ass=getopt(ass)) == -1 ) Ass = 0;
         if ( type(Colon=getopt(colon)) == -1 ) Colon = 0;          if ( type(Colon=getopt(colon)) == -1 ) Colon = 0;
         if ( type(Para=getopt(para)) == -1 ) Para = 0;          if ( type(Para=getopt(para)) == -1 ) Para = 0;
           if ( type(Trace=getopt(trace)) == -1 ) Trace = 0;
         Ord = 0;          Ord = 0;
         Tiso = Tint = Tpd = Text = Tint2 = 0;          Tiso = Tint = Tpd = Text = Tint2 = 0;
         RTiso = RTint = RTpd = RText = RTint2 = 0;          RTiso = RTint = RTpd = RText = RTint2 = 0;
 T00 = time();  T00 = time();
         G = fast_gb(B,V,Mod,Ord|trace=1);          G = fast_gb(B,V,Mod,Ord|trace=Trace);
         IntQ = [1]; QL = RL = []; First = 1;          IntQ = [1]; QL = RL = []; First = 1;
         for ( Level = 0; ; Level++ ) {          for ( Level = 0; ; Level++ ) {
 T0 = time();  T0 = time();
                 if ( First ) {                  if ( !Level ) {
                         PtR = prime_dec(G,V|indep=1,lexdec=Lexdec,mod=Mod,radical=1);                          PtR = prime_dec(G,V|indep=1,lexdec=Lexdec,mod=Mod,radical=1);
   ACCUM_TIME(Tfpd,RTfpd)
                         Pt = PtR[0]; IntPt = PtR[1]; Rad = IntPt;                          Pt = PtR[0]; IntPt = PtR[1]; Rad = IntPt;
                         if ( gen_gb_comp(G,Rad,Mod) ) {                          if ( gen_gb_comp(G,Rad,Mod) ) {
                                 /* Gt is radical and Gt = cap Pt */                                  /* Gt is radical and Gt = cap Pt */
Line 296  ACCUM_TIME(Tpd,RTpd)
Line 312  ACCUM_TIME(Tpd,RTpd)
 T0 = time();  T0 = time();
                 Rt = iso_comp(G,Pt,V,Ord|mod=Mod,iso=Iso,para=Para,intq=IntQ);                  Rt = iso_comp(G,Pt,V,Ord|mod=Mod,iso=Iso,para=Para,intq=IntQ);
 ACCUM_TIME(Tiso,RTiso)  ACCUM_TIME(Tiso,RTiso)
                   if ( !Level ) {
                           if ( Iso == 3 ) {
                                   NI = length(Rt);
                                   Q = IntQ;
 T0 = time();  T0 = time();
                 if ( Iso != 3 ) {                                  if ( Para ) {
                         IntQ = ideal_list_intersection(map(first,Rt),V,Ord|mod=Mod,para=Para,isgb=1);                                          for ( J = 0, Task = []; J < NI; J++ ) {
                                                   T = ["noro_pd.extract_qj",Q,V,Rt[J],Rad,Mod,SI,Colon,-1];
                                                   Task = cons(T,Task);
                                           }
                                           Task = reverse(Task);
                                           print("comps:",2); print(length(Task),2);
                                           Rt = para_exec(Para,Task);
                                   } else {
                                           for ( J = 0, T = []; J < NI; J++ ) {
                                                   TJ = extract_qj(Q,V,Rt[J],Rad,Mod,SI,Colon,-1);
                                                   T = cons(TJ,T);
                                           }
                                           Rt = reverse(T);
                                   }
   ACCUM_TIME(Text,RText)
                           }
                           print("");
   T0 = time();
                           Int = Rad;
                           for ( T = Rt; T != []; T = cdr(T) )
                                   if ( !gb_comp(car(T)[0],car(T)[1]) )
                                           Int = ideal_intersection_m(Int,car(T)[0],V,Ord|mod=Mod);
                           IntQ = nd_gr(Int,V,Mod,Ord);
   ACCUM_TIME(Tint,RTint)
                         RL = append(RL,[Rt]);                          RL = append(RL,[Rt]);
                   } else if ( Iso != 3 ) {
   T0 = time();
                           IntQ = ideal_list_intersection(map(first,Rt),V,Ord|mod=Mod,isgb=1);
                           RL = append(RL,[Rt]);
   ACCUM_TIME(Tint,RTint)
                 } else {                  } else {
                         NI = length(Rt);                          NI = length(Rt);
                         Q = IntQ;                          Q = IntQ;
                         for ( J = 0, T = []; J < NI; J++ ) {                          if ( Para ) {
                                 TJ = extract_qj(Q,V,Rt[J],Rad,Mod,SI,Colon,-1);                                  for ( J = 0, Task = []; J < NI; J++ ) {
                                 T = cons(TJ,T);                                          T = ["noro_pd.extract_qj",Q,V,Rt[J],Rad,Mod,SI,Colon,-1];
                                 IntQ = ideal_intersection_m(IntQ,TJ[0],V,Ord|mod=Mod);                                          Task = cons(T,Task);
                                   }
                                   Task = reverse(Task);
                                   print("comps:",2); print(length(Task),2);
   T0 = time();
                                   R = para_exec(Para,Task);
   ACCUM_TIME(Text,RText)
                                   print("");
   T0 = time();
                                   IntQ = ideal_list_intersection(cons(IntQ,map(first,R)),V,Ord|mod=Mod);
   ACCUM_TIME(Tint,RTint)
                                   RL = append(RL,[R]);
                           } else {
                                   for ( J = 0, T = []; J < NI; J++ ) {
   T0 = time();
                                           TJ = extract_qj(Q,V,Rt[J],Rad,Mod,SI,Colon,-1);
   ACCUM_TIME(Text,RText)
                                           T = cons(TJ,T);
   T0 = time();
                                           IntQ = ideal_intersection_m(IntQ,TJ[0],V,Ord|mod=Mod);
   ACCUM_TIME(Tint,RTint)
                                   }
                                   print("");
   T0 = time();
                                   IntQ = nd_gr(IntQ,V,Mod,Ord);
   ACCUM_TIME(Tint,RTint)
                                   T = reverse(T); RL = append(RL,[T]);
                         }                          }
                         print("");  
                         IntQ = nd_gr(IntQ,V,Mod,Ord);  
                         T = reverse(T); RL = append(RL,[T]);  
                 }                  }
                 QL = append(QL,[IntQ]);                  QL = append(QL,[IntQ]);
 ACCUM_TIME(Tint,RTint)  
                 if ( gen_gb_comp(IntQ,G,Mod) ) break;                  if ( gen_gb_comp(IntQ,G,Mod) ) break;
                 First = 0;  
         }          }
 T0 = time();  T0 = time();
         if ( Iso != 3 && !Ass )          if ( Iso != 3 && !Ass )
Line 325  ACCUM_TIME(Text,RText)
Line 394  ACCUM_TIME(Text,RText)
                 T1 = time();                  T1 = time();
                 Tall = T1[0]-T00[0]+T1[1]-T00[1]; RTall += T1[3]-T00[3];                  Tall = T1[0]-T00[0]+T1[1]-T00[1]; RTall += T1[3]-T00[3];
                 Tass = Tall-Text; RTass = RTall-RText;                  Tass = Tall-Text; RTass = RTall-RText;
                 print(["total",Tall,"ass",Tass,"pd",Tpd,"iso",Tiso,"int",Tint,"ext",Text]);                  print(["total",Tall,"ass",Tass,"pd",Tpd,"(fpd)",Tfpd,"iso",Tiso,"int",Tint,"ext",Text]);
                 print(["elapsed",RTall,"ass",RTass,"pd",RTpd,"iso",RTiso,"int",RTint,"ext",RText]);                  print(["elapsed",RTall,"ass",RTass,"pd",RTpd,"(fpd)",RTfpd,"iso",RTiso,"int",RTint,"ext",RText]);
         }          }
         return  RL;          return  RL;
 }  }
Line 347  def extract_comp(QL,RL,V,Rad) {
Line 416  def extract_comp(QL,RL,V,Rad) {
                                 Task = cons(T,Task);                                  Task = cons(T,Task);
                         }                          }
                 }                  }
                   Task = reverse(Task);
                 print("comps:",2); print(length(Task),2); print("");                  print("comps:",2); print(length(Task),2); print("");
                 R = para_exec(Para,Task);                  R = para_exec(Para,Task);
                 S = vector(L);                  S = vector(L);
Line 410  def colon_prime_dec(G,IntQ,V) {
Line 480  def colon_prime_dec(G,IntQ,V) {
                 print("->",2); print(length(M),2);                  print("->",2); print(length(M),2);
                 R = pd_simp_comp(R,V|mod=Mod);                  R = pd_simp_comp(R,V|mod=Mod);
                 print("->",2); print(length(R));                  print("->",2); print(length(R));
   #if 1
                 for ( Pt = [], T = R; T != []; T = cdr(T) ) {                  for ( Pt = [], T = R; T != []; T = cdr(T) ) {
                         Pi = prime_dec(car(T),V|indep=1,lexdec=Lexdec,mod=Mod);                          Pi = prime_dec(car(T),V|indep=1,lexdec=Lexdec,mod=Mod);
                         Pt = append(Pt,Pi);                          Pt = append(Pt,Pi);
                 }                  }
   #else
                   J = ideal_list_intersection(R,V,0|mod=Mod);
                   Pt = prime_dec(J,V|indep=1,lexdec=Lexdec,mod=Mod);
   #endif
         }          }
   #if 1
         Pt = pd_simp_comp(Pt,V|first=1,mod=Mod);          Pt = pd_simp_comp(Pt,V|first=1,mod=Mod);
   #endif
         return Pt;          return Pt;
 }  }
   
Line 1033  def locsat(G,V,L,S,Mod,IsGB,Iso,Q)
Line 1110  def locsat(G,V,L,S,Mod,IsGB,Iso,Q)
         if ( Iso==1 ) {          if ( Iso==1 ) {
                 QI = sat(G,S,V|isgb=IsGB,mod=Mod);                  QI = sat(G,S,V|isgb=IsGB,mod=Mod);
                 GI = elim_gb(QI,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);                  GI = elim_gb(QI,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);
                 GI = nd_gr(contraction(GI,V0|mod=Mod),V,Mod,0);                  GI = nd_gr(contraction(GI,V0|mod=Mod,allv=V),V,Mod,0);
         } else if ( Iso==0 ) {          } else if ( Iso==0 ) {
                 HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);                  HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);
                 GI = nd_gr(contraction(HI,V0|mod=Mod),V,Mod,0);                  GI = nd_gr(contraction(HI,V0|mod=Mod,allv=V),V,Mod,0);
                 GI = sat(GI,S,V|isgb=IsGB,mod=Mod);                  GI = sat(GI,S,V|isgb=IsGB,mod=Mod);
         } else if ( Iso==2 ) {          } else if ( Iso==2 ) {
                 HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);                  HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);
Line 1047  def locsat(G,V,L,S,Mod,IsGB,Iso,Q)
Line 1124  def locsat(G,V,L,S,Mod,IsGB,Iso,Q)
                         GI = nd_gr_trace(append(HI,[TV*S-1]),cons(TV,V0),                          GI = nd_gr_trace(append(HI,[TV*S-1]),cons(TV,V0),
                                 1,1,[[0,1],[0,length(V0)]]|gbblock=[[0,length(HI)]]);                                  1,1,[[0,1],[0,length(V0)]]|gbblock=[[0,length(HI)]]);
                 GI = elimination(GI,V);                  GI = elimination(GI,V);
                 GI = nd_gr(contraction(GI,V0|mod=Mod),V,Mod,0);                  GI = nd_gr(contraction(GI,V0|mod=Mod,allv=V),V,Mod,0);
         } else if ( Iso==3 ) {          } else if ( Iso==3 ) {
                 GI = sat(G,S,V|isgb=IsGB,mod=Mod);                  GI = sat(G,S,V|isgb=IsGB,mod=Mod);
         }          }
Line 1098  def prime_dec(B,V)
Line 1175  def prime_dec(B,V)
 {  {
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
         if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;          if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;
         if ( type(NoLexDec=getopt(lexdec)) == -1 ) LexDec = 0;          if ( type(LexDec=getopt(lexdec)) == -1 ) LexDec = 0;
         if ( type(Rad=getopt(radical)) == -1 ) Rad = 0;          if ( type(Rad=getopt(radical)) == -1 ) Rad = 0;
         B = map(sq,B,Mod);          B = map(sq,B,Mod);
         if ( LexDec )          if ( LexDec )
Line 1109  def prime_dec(B,V)
Line 1186  def prime_dec(B,V)
                 G = ideal_list_intersection(PD,V,0|mod=Mod);                  G = ideal_list_intersection(PD,V,0|mod=Mod);
                 PD = pd_remove_redundant_comp(G,PD,V,0|mod=Mod);                  PD = pd_remove_redundant_comp(G,PD,V,0|mod=Mod);
         }          }
           R = []; RL = [];
           for ( T = PD; T != []; T = cdr(T) ) {
                   PDT = prime_dec_main(car(T),V|indep=Indep,mod=Mod);
                   R = append(R,PDT[0]);
                   GT = nd_gr(PDT[1],V,Mod,0);
                   RL = append(RL,[GT]);
           }
           if ( LexDec ) R = pd_simp_comp(R,V|first=Indep,mod=Mod);
           if ( Rad ) {
                   G = ideal_list_intersection(RL,V,0|mod=Mod);
                   return [R,G];
           } else return R;
   }
   
   def prime_dec2(B,V)
   {
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;
           if ( type(LexDec=getopt(lexdec)) == -1 ) LexDec = 0;
           if ( type(Rad=getopt(radical)) == -1 ) Rad = 0;
           if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];
           B = map(sq,B,Mod);
           if ( LexDec )
                   PD = lex_predec1(B,V|mod=Mod);
           else
                   PD = [B];
           if ( length(PD) > 1 ) {
                   G = ideal_list_intersection(PD,V,0|mod=Mod);
                   PD = pd_remove_redundant_comp(G,PD,V,0|mod=Mod);
           }
         R = [];          R = [];
         for ( T = PD; T != []; T = cdr(T) )          for ( T = PD; T != []; T = cdr(T) )
                 R = append(prime_dec_main(car(T),V|indep=Indep,mod=Mod),R);                  R = append(prime_dec_main2(car(T),V|indep=Indep,mod=Mod,para=Para),R);
         if ( Indep ) {          if ( Indep ) {
                 G = ideal_list_intersection(map(first,R),V,0|mod=Mod);                  G = ideal_list_intersection(map(first,R),V,0|mod=Mod);
                 if ( LexDec ) R = pd_simp_comp(R,V|first=1,mod=Mod);                  R = pd_simp_comp(R,V|first=1,mod=Mod);
         } else {          } else {
                 G = ideal_list_intersection(R,V,0|mod=Mod);                  G = ideal_list_intersection(R,V,0|mod=Mod);
                 if ( LexDec ) R = pd_simp_comp(R,V|first=1,mod=Mod);                  R = pd_simp_comp(R,V|mod=Mod);
         }          }
         return Rad ? [R,G] : R;          return Rad ? [R,G] : R;
 }  }
   
   /* returns [PD,rad(I)] */
   
 def prime_dec_main(B,V)  def prime_dec_main(B,V)
 {  {
           Tpint = RTpint = 0;
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
         if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;          if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;
         G = fast_gb(B,V,Mod,0);          G = fast_gb(B,V,Mod,0);
Line 1133  def prime_dec_main(B,V)
Line 1243  def prime_dec_main(B,V)
         for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);          for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);
         if ( Mod ) DG = map(dp_mod,DG,Mod,[]);          if ( Mod ) DG = map(dp_mod,DG,Mod,[]);
         while ( 1 ) {          while ( 1 ) {
                   print([length(PD)],2);
                 /* rad(G) subset IntP */                  /* rad(G) subset IntP */
                 /* check if IntP subset rad(G) */                  /* check if IntP subset rad(G) */
                 /* print([length(PD),length(IntP)],2); */                  /* print([length(PD),length(IntP)],2); */
                 for ( T = IntP; T != []; T = cdr(T) ) {                  for ( T = IntP; T != []; T = cdr(T) )
                         if ( (GNV = radical_membership(car(T),G,V|mod=Mod,isgb=1,dg=[DG,Ind])) ) {                          if ( (G0 = radical_membership_sat(car(T),G,V|mod=Mod,isgb=1,dg=[DG,Ind])) ) {
                                 F = car(T);                                  F = car(T);
                                 break;                                  break;
                         }                          }
                   if ( T == [] ) {
                           print(["pint",Tpint,"rpint",RTpint]);
                           return [PD,IntP];
                 }                  }
                 if ( T == [] ) return PD;  
   
                 /* GNV = [GB(<NV*F-1,G>),NV] */  
                 G1 = fast_gb(GNV[0],cons(GNV[1],V),Mod,[[0,1],[0,length(V)]]);  
                 G0 = elimination(G1,V);  
                 PD0 = zprimecomp(G0,V,Indep|mod=Mod);                  PD0 = zprimecomp(G0,V,Indep|mod=Mod);
                 if ( Indep ) {                  Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);
                         Int = ideal_list_intersection(PD0[0],V,0|mod=Mod);                  PD = append(PD,PD0);
                         IndepSet = PD0[1];  #if 1
                         for ( PD1 = [], T = PD0[0]; T != []; T = cdr(T) )  T0=time();
                                 PD1 = cons([car(T),IndepSet],PD1);  
                         PD = append(PD,reverse(PD1));  
                 } else {  
                         Int = ideal_list_intersection(PD0,V,0|mod=Mod);  
                         PD = append(PD,PD0);  
                 }  
 #if 0  
                 IntP = ideal_intersection_m(IntP,Int,V,0|mod=Mod);                  IntP = ideal_intersection_m(IntP,Int,V,0|mod=Mod);
                   dp_ord(0); DC = map(dp_ptod,IntP,V);
                   DC = qsort(DC,comp_tord); IntP = map(dp_dtop,DC,V);
   ACCUM_TIME(Tpint,RTpint)
 #else  #else
                 IntP = ideal_intersection(IntP,Int,V,0                  IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);
                         |mod=Mod,gbblock=[[0,length(IntP)]]);  
 #endif  #endif
         }          }
 }  }
   
   localf callsat,callzcomp;
   
   def callsat(F,G,V,Mod,DG)
   {
           return radical_membership(F,G,V|mod=Mod,isgb=1,dg=DG,sat=1);
   }
   
   def callzcomp(F,V,Indep,Mod)
   {
           PD0 = zprimecomp(F,V,Indep|mod=Mod);
           Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);
           return [PD0,Int];
   }
   
   def prime_dec_main2(B,V)
   {
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;
           if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];
           NPara = length(Para);
   
           G = fast_gb(B,V,Mod,0);
           IntP = [1];
           PD = [];
           DG = ltov(map(dp_ptod,G,V));
           for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);
           if ( Mod ) DG = map(dp_mod,DG,Mod,[]);
           if ( NPara )
                   while ( 1 ) {
                           IntPM = mingen(IntP,V);
                           for ( T = IntPM, CallSat = []; T != []; T = cdr(T) )
                                   CallSat = cons(["noro_pd.callsat",car(T),G,V,Mod,[DG,Ind]],CallSat);
                           CallSat = reverse(CallSat);
                           /* SatL = [[..],0,[...],...] */
                           SatL = para_exec(Para,CallSat);
                           for ( T = SatL, Sat = []; T != []; T = cdr(T) ) if ( car(T) ) Sat = cons(car(T),Sat);
                           if ( Sat == [] ) return PD;
                           print(length(Sat),2); print("->",2);
                           Sat = remove_identical_comp(Sat|mod=Mod);
                           print(length(Sat));
                           for ( T = Sat, CallComp = []; T != []; T = cdr(T) )
                                   CallComp = cons(["noro_pd.callzcomp",car(T),V,Indep,Mod],CallComp);
                           CallComp = reverse(CallComp);
                           /* PDL = [[PD0,Int],...] */
                           PDL = para_exec(Para,CallComp);
                           for ( T = PDL; T != []; T = cdr(T) ) PD = append(PD,car(T)[0]);
                           Int = ideal_list_intersection(map(second,PDL),V,0|mod=Mod);
                           IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);
                   }
           else
                   while ( 1 ) {
                           /* rad(G) subset IntP */
                           /* check if IntP subset rad(G) */
                           /* print([length(PD),length(IntP)],2); */
                           Sat = [];
                           IntPM = mingen(IntP,V);
                           for ( T = IntPM; T != [] && length(Sat) < 16; T = cdr(T) )
                                   if ( G0 = radical_membership(car(T),G,V|mod=Mod,isgb=1,dg=[DG,Ind],sat=1) )
                                           Sat = cons(G0,Sat);
                           if ( Sat == [] ) return PD;
                           print(length(Sat),2); print("->",2);
                           Sat = remove_identical_comp(Sat|mod=Mod);
                           print(length(Sat));
                           for ( T = Sat; T != []; T = cdr(T) ) {
                                   PD0 = zprimecomp(car(T),V,Indep|mod=Mod); PD = append(PD,PD0);
                                   Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);
                                   IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);
                           }
                   }
   }
   
 /* pre-decomposition */  /* pre-decomposition */
   
 def lex_predec1(B,V)  def lex_predec1(B,V)
Line 1228  def complete_qdecomp(GD,V,Mod)
Line 1403  def complete_qdecomp(GD,V,Mod)
         NV = ttttt;          NV = ttttt;
         M = gen_minipoly(cons(NV-U,GQ),cons(NV,V),PV,0,NV,Mod);          M = gen_minipoly(cons(NV-U,GQ),cons(NV,V),PV,0,NV,Mod);
         M = ppart(M,NV,Mod);          M = ppart(M,NV,Mod);
         MF = Mod ? modfctr(M) : fctr(M);          MF = Mod ? modfctr(M,Mod) : fctr(M);
         R = [];          R = [];
         for ( T = cdr(MF); T != []; T = cdr(T) ) {          for ( T = cdr(MF); T != []; T = cdr(T) ) {
                 S = car(T);                  S = car(T);
Line 1325  def complete_decomp(GD,V,Mod)
Line 1500  def complete_decomp(GD,V,Mod)
         NV = ttttt;          NV = ttttt;
         M = gen_minipoly(cons(NV-U,G),cons(NV,V),PV,0,NV,Mod);          M = gen_minipoly(cons(NV-U,G),cons(NV,V),PV,0,NV,Mod);
         M = ppart(M,NV,Mod);          M = ppart(M,NV,Mod);
         MF = Mod ? modfctr(M) : fctr(M);          MF = Mod ? modfctr(M,Mod) : fctr(M);
         if ( length(MF) == 2 ) return [G];          if ( length(MF) == 2 ) return [G];
         R = [];          R = [];
         for ( T = cdr(MF); T != []; T = cdr(T) ) {          for ( T = cdr(MF); T != []; T = cdr(T) ) {
Line 1441  def zprimecomp(G,V,Indep) {
Line 1616  def zprimecomp(G,V,Indep) {
         for ( T = PD; T != []; T = cdr(T) ) {          for ( T = PD; T != []; T = cdr(T) ) {
                 U = contraction(car(T),V0|mod=Mod);                  U = contraction(car(T),V0|mod=Mod);
                 U = nd_gr(U,V,Mod,0);                  U = nd_gr(U,V,Mod,0);
                 R = cons(U,R);                  R = cons(Indep?[U,W]:U,R);
         }          }
         if ( Indep ) return [R,W];          return R;
         else return R;  
 }  }
   
 def fast_gb(B,V,Mod,Ord)  def fast_gb(B,V,Mod,Ord)
Line 1511  def elim_gb(G,V,PV,Mod,Ord)
Line 1685  def elim_gb(G,V,PV,Mod,Ord)
                 G = competitive_exec(EProcs,Arg0,Arg1);                  G = competitive_exec(EProcs,Arg0,Arg1);
         } else if ( GBRat ) {          } else if ( GBRat ) {
                 G1 = nd_gr(G,append(V,PV),0,O1);                  G1 = nd_gr(G,append(V,PV),0,O1);
             G1 = nd_gr_postproc(G1,V,0,Ord,0);                  if ( GBRat == 1 )
                   G1 = nd_gr_postproc(G1,V,0,Ord,0|nora=1);
                 return G1;                  return G1;
         } else          } else
 #if 1  #if 1
Line 1569  def find_npos(GD,V,PV,Mod)
Line 1744  def find_npos(GD,V,PV,Mod)
 {  {
         N = length(V); PN = length(PV);          N = length(V); PN = length(PV);
         G = GD[0]; D = GD[1]; LD = D[N];          G = GD[0]; D = GD[1]; LD = D[N];
           DH = map(dp_dtop,map(dp_ht,map(dp_ptod,D,V)),V);
         Ord0 = dp_ord(); dp_ord(0);          Ord0 = dp_ord(); dp_ord(0);
         HC = map(dp_hc,map(dp_ptod,G,V));          HC = map(dp_hc,map(dp_ptod,G,V));
         dp_ord(Ord0);          dp_ord(Ord0);
Line 1582  def find_npos(GD,V,PV,Mod)
Line 1758  def find_npos(GD,V,PV,Mod)
         NV = ttttt;          NV = ttttt;
         for ( B = 2; ; B++ ) {          for ( B = 2; ; B++ ) {
                 for ( J = N-2; J >= 0; J-- ) {                  for ( J = N-2; J >= 0; J-- ) {
                         for ( U = 0, K = J; K < N; K++ )                          for ( U = 0, K = J; K < N; K++ ) {
                                   if ( DH[K] == V[K] ) continue;
                                 U += rsgn()*((random()%B+1))*V[K];                                  U += rsgn()*((random()%B+1))*V[K];
                           }
   #if 0
                         M = minipolym(G,V,0,U,NV,Mod);                          M = minipolym(G,V,0,U,NV,Mod);
   #else
                           M = gen_minipoly(cons(NV-U,G),cons(NV,V),PV,0,NV,Mod);
   #endif
                         if ( deg(M,NV) == LD ) return U;                          if ( deg(M,NV) == LD ) return U;
                 }                  }
         }          }
Line 1592  def find_npos(GD,V,PV,Mod)
Line 1774  def find_npos(GD,V,PV,Mod)
   
 def gen_minipoly(G,V,PV,Ord,VI,Mod)  def gen_minipoly(G,V,PV,Ord,VI,Mod)
 {  {
           O0 = dp_ord();
         if ( PV == [] ) {          if ( PV == [] ) {
                 NV = sssss;                  NV = sssss;
                 if ( Mod )                  if ( Mod )
                         M = minipolym(G,V,Ord,VI,NV,Mod);                          M = minipolym(G,V,Ord,VI,NV,Mod);
                 else                  else
                         M = minipoly(G,V,Ord,VI,NV);                          M = minipoly(G,V,Ord,VI,NV);
                   dp_ord(O0);
                 return subst(M,NV,VI);                  return subst(M,NV,VI);
         }          }
         W = setminus(V,[VI]);          W = setminus(V,[VI]);
Line 1640  def gen_minipoly(G,V,PV,Ord,VI,Mod)
Line 1824  def gen_minipoly(G,V,PV,Ord,VI,Mod)
                 G = nd_gr_trace(G,PV1,1,GBCheck,[[0,1],[0,length(PV)]]|nora=1);                  G = nd_gr_trace(G,PV1,1,GBCheck,[[0,1],[0,length(PV)]]|nora=1);
         for ( M = car(G), T = cdr(G); T != []; T = cdr(T) )          for ( M = car(G), T = cdr(G); T != []; T = cdr(T) )
                 if ( deg(car(T),VI) < deg(M,VI) ) M = car(T);                  if ( deg(car(T),VI) < deg(M,VI) ) M = car(T);
           dp_ord(O0);
         return M;          return M;
 }  }
   
Line 1685  def maxindep(B,V,O)
Line 1870  def maxindep(B,V,O)
         return R;          return R;
 }  }
   
   def maxindep2(B,V,O)
   {
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           G = fast_gb(B,V,Mod,O);
           Old = dp_ord();
           dp_ord(O);
           H = map(dp_dtop,map(dp_ht,map(dp_ptod,G,V)),V);
           H = map(sq,H,0);
           H = nd_gr(H,V,0,0);
           H = monodec0(H,V);
           N = length(V);
           Dep = [];
           for ( T = H, Len = N+1; T != []; T = cdr(T) ) {
                   M = length(car(T));
                   if ( M < Len ) {
                           Dep = [car(T)];
                           Len = M;
                   } else if ( M == Len )
                           Dep = cons(car(T),Dep);
           }
           R = [];
           for ( T = Dep; T != []; T = cdr(T) )
                   R = cons(setminus(V,car(T)),R);
           dp_ord(Old);
           return reverse(R);
   }
   
   
 /* ideal operations */  /* ideal operations */
 def contraction(G,V)  def contraction(G,V)
 {  {
           if ( type(AllV=getopt(allv)) == -1 ) AllV = 0;
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
   
           if ( RepColon ) return contraction_m(G,V|allv=AllV,mod=Mod);
   
         C = [];          C = [];
         for ( T = G; T != []; T = cdr(T) ) {          for ( T = G; T != []; T = cdr(T) ) {
                 C1 = dp_hc(dp_ptod(car(T),V));                  C1 = dp_hc(dp_ptod(car(T),V));
Line 1698  def contraction(G,V)
Line 1915  def contraction(G,V)
         }          }
         W = vars(G);          W = vars(G);
         PV = setminus(W,V);          PV = setminus(W,V);
         W = append(V,PV);          if ( AllV ) W = AllV;
           else W = append(V,PV);
         NV = ttttt;          NV = ttttt;
         for ( T = C, S = 1; T != []; T = cdr(T) )          if ( SuccSat ) {
                 S *= car(T);                  W1 = cons(NV,W);
         G = saturation([G,NV],S,W|mod=Mod);                  O1 = [[0,1],[0,length(W)]];
                   Block = [];
                   for ( T = C; T != []; T = cdr(T) ) {
                           G1 = nd_gr(append(G,[NV*car(T)-1]),W1,Mod,O1|gbblock=Block);
                           G = elimination(G1,W);
                           Block = [[0,length(G)]];
                   }
           } else {
                   for ( T = C, S = 1; T != []; T = cdr(T) )
                           S *= car(T);
                   G = saturation([G,NV],S,W|mod=Mod);
           }
         return G;          return G;
 }  }
   
   def contraction_m(G,V)
   {
           if ( type(AllV=getopt(allv)) == -1 ) AllV = 0;
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           C = [];
           for ( T = G; T != []; T = cdr(T) ) {
                   C1 = dp_hc(dp_ptod(car(T),V));
                   S = gen_fctr(C1,Mod);
                   for ( S = cdr(S); S != []; S = cdr(S) )
                           if ( !member(S[0][0],C) ) C = cons(S[0][0],C);
           }
           W = vars(G);
           PV = setminus(W,V);
           if ( AllV ) W = AllV;
           else W = append(V,PV);
           H = H0 = G;
           while ( 1 ) {
                   for ( T = C; T != []; T = cdr(T) )
                           H = map(sdiv,ideal_intersection_m([car(T)],H,W,0),car(T));
                   H = nd_gr(H,W,0,0);
                   if ( gb_comp(H0,H) ) break;
                   else H0 = H;
           }
           return H;
   }
   
 def ideal_list_intersection(L,V,Ord)  def ideal_list_intersection(L,V,Ord)
 {  {
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
         if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;          if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;
         if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];  
         N = length(L);          N = length(L);
         if ( N == 0 ) return [1];          if ( N == 0 ) return [1];
         if ( N == 1 )          if ( N == 1 )
                 return IsGB ? L[0] : fast_gb(L[0],V,Mod,Ord);                  return IsGB ? L[0] : fast_gb(L[0],V,Mod,Ord);
         if ( N > 2 && (Len = length(Para)) >= 2 ) {          else {
                 Div = N >= 2*Len ? Len : 2;  
                 QR = iqr(N,Div); Q = QR[0]; R = QR[1];  
                 T = []; K = 0;  
                 for ( I = 0; I < Div; I++ ) {  
                         LenI = I<R? Q+1 : Q;  
                         if ( LenI ) {  
                                 for ( LI = [], J = 0; J < LenI; J++ ) LI = cons(L[K++],LI);  
                                 TI = ["noro_pd.call_ideal_list_intersection",LI,V,Mod,Ord,IsGB];  
                                 T = cons(TI,T);  
                         }  
                 }  
                 Tint = para_exec(Para,T);  
                 return ideal_list_intersection(Tint,V,Ord|mod=Mod,para=Para,isgb=IsGB);  
         } else {  
                 for ( I = 0, T = [1]; I < N; I++ )                  for ( I = 0, T = [1]; I < N; I++ )
                         T = ideal_intersection_m(T,L[I],V,Ord|mod=Mod);                          T = ideal_intersection_m(T,L[I],V,Ord|mod=Mod);
                 T = nd_gr(T,V,Mod,Ord);                  T = nd_gr(T,V,Mod,Ord);
Line 1808  def radical_membership(F,G,V) {
Line 2048  def radical_membership(F,G,V) {
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
         if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;          if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;
         if ( type(L=getopt(dg)) == -1 ) L = 0;          if ( type(L=getopt(dg)) == -1 ) L = 0;
           if ( type(Sat=getopt(sat)) == -1 ) Sat = 0;
         dp_ord(0);          dp_ord(0);
         if ( L ) { DG = L[0]; Ind = L[1]; }          if ( L ) { DG = L[0]; Ind = L[1]; }
         else {          else {
Line 1830  def radical_membership(F,G,V) {
Line 2071  def radical_membership(F,G,V) {
                         |gbblock=[[0,length(G)]]);                          |gbblock=[[0,length(G)]]);
         else          else
                 T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,0);                  T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,0);
         if ( type(car(T)) != 1 ) return [T,NV];          if ( type(car(T)) == 1 ) return 0;
         else return 0;          else if ( Sat ) {
                   G1 = fast_gb(T,cons(NV,V),Mod,[[0,1],[0,length(V)]]);
                   G0 = elimination(G1,V);
                   return G0;
           } else return [T,NV];
 }  }
   
   def radical_membership_sat(F,G,V) {
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;
           if ( type(L=getopt(dg)) == -1 ) L = 0;
           dp_ord(0);
           if ( L ) { DG = L[0]; Ind = L[1]; }
           else {
                   DG = ltov(map(dp_ptod,G,V));
                   if ( Mod ) DG = map(dp_mod,DG,Mod,[]);
                   for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);
           }
           DF = dp_ptod(F,V); DFI = dp_ptod(1,V);
           if ( Mod ) {
                   DF = dp_mod(DF,Mod,[]); DFI = dp_mod(DFI,Mod,[]);
                   setmod(Mod);
           }
           for ( I = 0; I < 3; I++ ) {
                   DFI = Mod?dp_nf_mod(Ind,DF*DFI,DG,0,Mod):dp_nf(Ind,DF*DFI,DG,0);
                   if ( !DFI ) return 0;
           }
           NV = ttttt;
           if ( IsGB )
                   T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,[[0,1],[0,length(V)]]
                           |gbblock=[[0,length(G)]]);
           else
                   T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,[[0,1],[0,length(V)]]);
           if ( type(car(T)) == 1 ) return 0;
           G0 = elimination(T,V);
           return G0;
   }
   
 def modular_radical_membership(F,G,V) {  def modular_radical_membership(F,G,V) {
         if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;          if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
         if ( Mod )          if ( Mod )
Line 2212  def pd_remove_redundant_comp(G,P,V,Ord)
Line 2488  def pd_remove_redundant_comp(G,P,V,Ord)
         return reverse(T);          return reverse(T);
 }  }
   
   def remove_identical_comp(L)
   {
           if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;
           if ( length(L) == 1 )  return L;
   
           A = ltov(L); N = length(A);
           for ( I = 0; I < N; I++ ) {
                   if ( !A[I] ) continue;
                   for ( J = I+1; J < N; J++ )
                           if ( A[J] &&
                                   gen_gb_comp(A[I],A[J],Mod) ) A[J] = 0;
           }
           for ( I = 0, T = []; I < N; I++ ) if ( A[I] ) T = cons(A[I],T);
           return reverse(T);
   }
   
 /* polynomial operations */  /* polynomial operations */
   
 def ppart(F,V,Mod)  def ppart(F,V,Mod)
Line 2606  def call_func(Arg)
Line 2898  def call_func(Arg)
         return call(strtov(F),cdr(Arg));          return call(strtov(F),cdr(Arg));
 }  }
   
   def call_func_serial(Arg,Serial)
   {
           F = car(Arg);
           return [call(strtov(F),cdr(Arg)),Serial];
   }
   
 def competitive_exec(P,Arg0,Arg1)  def competitive_exec(P,Arg0,Arg1)
 {  {
         P0 = P[0]; P1 = P[1];          P0 = P[0]; P1 = P[1];
Line 2636  def para_exec(Proc,Task) {
Line 2934  def para_exec(Proc,Task) {
         Free = Proc;          Free = Proc;
         N = length(Task);          N = length(Task);
         R = [];          R = [];
           print([N],2); print("->",2);
           Serial = 0;
         while ( N ) {          while ( N ) {
                 while ( Task != [] && Free != [] ) {                  while ( Task != [] && Free != [] ) {
                         T = car(Task); Task = cdr(Task);                          T = car(Task); Task = cdr(Task);
                         ox_cmo_rpc(car(Free),"noro_pd.call_func",T);                          ox_rpc(car(Free),"noro_pd.call_func_serial",T,Serial++);
                         ox_push_cmd(car(Free),258); Free = cdr(Free);                          ox_push_cmd(car(Free),258); Free = cdr(Free);
                 }                  }
                 Finish0 = Finish = ox_select(Proc);                  Finish0 = Finish = ox_select(Proc);
Line 2649  def para_exec(Proc,Task) {
Line 2949  def para_exec(Proc,Task) {
                         R = cons(L,R);                          R = cons(L,R);
                         N--;                          N--;
                 }                  }
                   print([N],2);
                 Free = append(Free,Finish0);                  Free = append(Free,Finish0);
         }          }
         print("");          print("");
         return reverse(R);          R = qsort(R,comp_by_second);
           R = map(first,R);
           return R;
 }  }
   
 def redbase(B,V,Mod,Ord)  def redbase(B,V,Mod,Ord)
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.8
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>