[BACK]Return to sp CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / lib

Diff for /OpenXM_contrib2/asir2000/lib/sp between version 1.8 and 1.19

version 1.8, 2000/08/22 05:04:23 version 1.19, 2018/04/09 04:07:27
Line 45 
Line 45 
  * 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/lib/sp,v 1.7 2000/08/21 08:31:43 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/lib/sp,v 1.18 2018/04/06 07:40:44 noro Exp $
 */  */
 /*  /*
         sp : functions related to algebraic number fields          sp : functions related to algebraic number fields
   
         Revision History:          Revision History:
   
           2001/10/12    noro    if USE_PARI_FACTOR is nonzero, pari factor is called
         2000/03/10    noro    fixed several bugs around gathering algebraic numbers          2000/03/10    noro    fixed several bugs around gathering algebraic numbers
         1999/08/24    noro    modified for 1999 release version          1999/08/24    noro    modified for 1999 release version
 */  */
Line 59 
Line 60 
 #include "defs.h"  #include "defs.h"
   
 extern ASCENT,GCDTIME,UFTIME,RESTIME,SQTIME,PRINT$  extern ASCENT,GCDTIME,UFTIME,RESTIME,SQTIME,PRINT$
 extern Ord$  extern SpOrd$
   extern USE_PARI_FACTOR$
   
   /* gen_sp can handle non-monic poly */
   
   def gen_sp(P)
   {
           P = ptozp(P);
           V = var(P);
           D = deg(P,V);
           LC = coef(P,D,V);
           F = LC^(D-1)*subst(P,V,V/LC);
           /* F must be monic */
           L = sp(F);
           return cons(map(subst,car(L),V,LC*V),cdr(L));
   }
   
 def sp(P)  def sp(P)
 {  {
         RESTIME=UFTIME=GCDTIME=SQTIME=0;          RESTIME=UFTIME=GCDTIME=SQTIME=0;
Line 195  def flatmf(L) {
Line 211  def flatmf(L) {
 def af(P,AL)  def af(P,AL)
 {  {
         RESTIME=UFTIME=GCDTIME=SQTIME=0;          RESTIME=UFTIME=GCDTIME=SQTIME=0;
       V = var(P);
       LC = coef(P,deg(P,V),V);
       if ( ntype(LC) != 1 )
         P = simpalg(1/LC*P);
         S = reverse(asq(P));          S = reverse(asq(P));
         for ( L = []; S != []; S = cdr(S) ) {          for ( L = []; S != []; S = cdr(S) ) {
                 FM = car(S); F = FM[0]; M = FM[1];                  FM = car(S); F = FM[0]; M = FM[1];
Line 211  def af_sp(P,AL,HINT)
Line 231  def af_sp(P,AL,HINT)
 {  {
         if ( !P || type(P) == NUM )          if ( !P || type(P) == NUM )
                 return [P];                  return [P];
       V = var(P);
       LC = coef(P,deg(P,V),V);
       if ( ntype(LC) != 1 )
         P = simpalg(1/LC*P);
         P1 = simpcoef(simpalg(P));          P1 = simpcoef(simpalg(P));
         return af_spmain(P1,AL,1,HINT,P1,[]);          return af_spmain(P1,AL,1,HINT,P1,[]);
 }  }
Line 592  def simpcoef(P) {
Line 616  def simpcoef(P) {
 }  }
   
 def ufctrhint_heuristic(P,HINT,PP,SHIFT) {  def ufctrhint_heuristic(P,HINT,PP,SHIFT) {
           if ( USE_PARI_FACTOR )
                   return pari_ufctr(P);
           else
                   return asir_ufctrhint_heuristic(P,HINT,PP,SHIFT);
   }
   
   def pari_ufctr(P) {
           F = pari(factpol,P);
           S = size(F);
           for ( I = S[0]-1, R = []; I >= 0; I-- )
                   R = cons(vtol(F[I]),R);
           return cons([1,1],R);
   }
   
   def asir_ufctrhint_heuristic(P,HINT,PP,SHIFT) {
         V = var(P); D = deg(P,V);          V = var(P); D = deg(P,V);
         if ( D == HINT )          if ( D == HINT )
                 return [[P,1]];                  return [[P,1]];
Line 628  def ufctrhint2(P,HINT,PP,AL)
Line 667  def ufctrhint2(P,HINT,PP,AL)
                 return [[P,1]];                  return [[P,1]];
         if ( AL == [] )          if ( AL == [] )
                 return ufctrhint(P,HINT);                  return ufctrhint(P,HINT);
   
           /* if P != norm(PP) then call the generic ufctrhint() */
           for ( T = AL, E = 1; T != []; T = cdr(T) ) {
                   D = defpoly(car(T)); E *= deg(D,var(D));
           }
           if ( E*deg(PP,var(PP)) != deg(P,var(P)) )
                   return ufctrhint(P,HINT);
   
           /* P = norm(PP) */
         L = resfctr(algptorat(PP),map(defpoly,AL),map(algtorat,AL),P);          L = resfctr(algptorat(PP),map(defpoly,AL),map(algtorat,AL),P);
         for ( T = reverse(L[1]), DL = []; T != []; T = cdr(T) )          for ( T = reverse(L[1]), DL = []; T != []; T = cdr(T) )
                 DL = cons(deg(car(car(T)),a_),DL);                  DL = cons(deg(car(car(T)),a_),DL);
Line 772  def norm_ch_lag(V,VM,P,P0) {
Line 820  def norm_ch_lag(V,VM,P,P0) {
   
 def cr_gcda(P1,P2)  def cr_gcda(P1,P2)
 {  {
         if ( !(V = var(P1)) || !var(P2) )          if ( !P1 )
                   return P2;
           if ( !P2 )
                   return P1;
           if ( !var(P1) || !var(P2) )
                 return 1;                  return 1;
           V = var(P1);
         EXT = union_sort(getalgtreep(P1),getalgtreep(P2));          EXT = union_sort(getalgtreep(P1),getalgtreep(P2));
         if ( EXT == [] )          if ( EXT == [] )
                 return gcd(P1,P2);                  return gcd(P1,P2);
Line 801  def cr_gcda(P1,P2)
Line 854  def cr_gcda(P1,P2)
                                 break;                                  break;
                 if ( J != length(DL) )                  if ( J != length(DL) )
                         continue;                          continue;
                 Ord = 2; NOSUGAR = 1;                  SpOrd = 2; NOSUGAR = 1;
                 T = ag_mod(G1 % MOD,G2 % MOD,ML,VL,MOD);                  T = ag_mod(G1 % MOD,G2 % MOD,ML,VL,MOD);
                 if ( dp_gr_print() )                  if ( dp_gr_print() )
                         print(".");                          print(".");
Line 1015  def ag_mod(F1,F2,D,VL,MOD)
Line 1068  def ag_mod(F1,F2,D,VL,MOD)
         VL = cons(V,VL); B = append([F1,F2],D); N = length(VL);          VL = cons(V,VL); B = append([F1,F2],D); N = length(VL);
     while ( 1 ) {      while ( 1 ) {
                 FLAGS = dp_gr_flags(); dp_gr_flags(["Reverse",1,"NoSugar",1]);                  FLAGS = dp_gr_flags(); dp_gr_flags(["Reverse",1,"NoSugar",1]);
                 G = dp_gr_mod_main(B,VL,0,MOD,Ord);                  G = dp_gr_mod_main(B,VL,0,MOD,SpOrd);
                 dp_gr_flags(FLAGS);                  dp_gr_flags(FLAGS);
                 if ( length(G) == 1 )                  if ( length(G) == 1 )
                         return 1;                          return 1;
Line 1249  def ag_mod_single6(F1,F2,D,MOD)
Line 1302  def ag_mod_single6(F1,F2,D,MOD)
   
 def inverse_by_gr_mod(C,D,MOD)  def inverse_by_gr_mod(C,D,MOD)
 {  {
         Ord = 2;          SpOrd = 2;
         dp_gr_flags(["NoSugar",1]);          dp_gr_flags(["NoSugar",1]);
         G = dp_gr_mod_main(cons(x*C-1,D),cons(x,vars(D)),0,MOD,Ord);          G = dp_gr_mod_main(cons(x*C-1,D),cons(x,vars(D)),0,MOD,SpOrd);
         dp_gr_flags(["NoSugar",0]);          dp_gr_flags(["NoSugar",0]);
         if ( length(G) == 1 )          if ( length(G) == 1 )
                 return 1;                  return 1;
Line 1310  def resfctr(F,L,V,N)
Line 1363  def resfctr(F,L,V,N)
         N = ptozp(N);          N = ptozp(N);
         V0 = var(N);          V0 = var(N);
         DN = diff(N,V0);          DN = diff(N,V0);
         for ( I = 0, J = 2, Len = deg(N,V0)+1; I < 5; J++ ) {          LC = coef(N,deg(N,V0),V0);
                 M = prime(J);          LCD = coef(DN,deg(DN,V0),V0);
                 G = gcd(N,DN,M);    J = 2;
                 if ( !deg(G,V0) ) {    while ( 1 ) {
                         I++;      Len = deg(N,V0)+1;
                         T = nfctr_mod(N,M);            for ( I = 0; I < 5; J++ ) {
                         if ( T < Len ) {                    M = prime(J);
                                 Len = T; M0 = M;                    if ( !(LC%M) || !(LCD%M))
                         }                            continue;
                 }                    G = gcd(N,DN,M);
         }                    if ( !deg(G,V0) ) {
         S = spm(L,V,M0);                            I++;
                             T = nfctr_mod(N,M);
                             if ( T < Len ) {
                                     Len = T; M0 = M;
                             }
                     }
             }
             S = spm(L,V,M0);
       if ( S ) break;
     }
         T = resfctr_mod(F,S,M0);          T = resfctr_mod(F,S,M0);
         return [T,S,M0];          return [T,S,M0];
 }  }
Line 1335  def resfctr_mod(F,L,M)
Line 1397  def resfctr_mod(F,L,M)
                 C = res(var(MP),B,MP) % M;                  C = res(var(MP),B,MP) % M;
                 R = cons(flatten(cdr(modfctr(C,M))),R);                  R = cons(flatten(cdr(modfctr(C,M))),R);
         }          }
         return R;          return reverse(R);
 }  }
   
 def flatten(L)  def flatten(L)
Line 1351  def spm(L,V,M)
Line 1413  def spm(L,V,M)
                 U = modfctr(car(L),M);                  U = modfctr(car(L),M);
                 for ( T = cdr(U), R = []; T != []; T = cdr(T) ) {                  for ( T = cdr(U), R = []; T != []; T = cdr(T) ) {
                         S = car(T);                          S = car(T);
         if ( S[1] > 1 ) return 0;
                         R = cons([subst(S[0],var(S[0]),a_),[var(S[0]),a_]],R);                          R = cons([subst(S[0],var(S[0]),a_),[var(S[0]),a_]],R);
                 }                  }
                 return R;                  return R;
         }          }
         L1 = spm(cdr(L),cdr(V),M);          L1 = spm(cdr(L),cdr(V),M);
     if ( !L1 ) return 0;
         F0 = car(L); V0 = car(V); VR = cdr(V);          F0 = car(L); V0 = car(V); VR = cdr(V);
         for ( T = L1, R = []; T != []; T = cdr(T) ) {          for ( T = L1, R = []; T != []; T = cdr(T) ) {
                 S = car(T);                  S = car(T);
Line 1363  def spm(L,V,M)
Line 1427  def spm(L,V,M)
                 U = fctr_mod(F1,V0,S[0],M);                  U = fctr_mod(F1,V0,S[0],M);
                 VS = var(S[0]);                  VS = var(S[0]);
                 for ( W = U; W != []; W = cdr(W) ) {                  for ( W = U; W != []; W = cdr(W) ) {
         if ( car(W)[1] > 1 ) return 0;
                         A = car(car(W));                          A = car(car(W));
                         if ( deg(A,V0) == 1 ) {                          if ( deg(A,V0) == 1 ) {
                                 A = monic_mod(A,V0,S[0],M);                                  A = monic_mod(A,V0,S[0],M);
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.19
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>