Changeset 2fede6 in git


Ignore:
Timestamp:
Jun 13, 2014, 9:48:07 AM (10 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '79dfb9a6d258bfeb991428bdb25b8f55e9e809b2')
Children:
09b10c0468bacceddd8595ab5b61128767ca0b49
Parents:
38a53c048e362151c5c6f95afd4ff65bb32f577c
Message:
rewrite of crypto.lib: use bigint instead of number
Files:
6 deleted
53 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/aksaka.lib

    r38a53c0 r2fede6  
    11////////////////////////////////////////////////////////////////////////////////
    2 version="version aksaka.lib 4.0.0.0 Jun_2013 "; // $Id$
     2version="version aksaka.lib 4.0.0.0 Jun_2014 "; // $Id$
    33category="Teaching";
    44info="
     
    212212}
    213213//////////////////////////////////////////////////////////////////////////
    214 proc euler(number r)
     214proc euler(bigint r)
    215215"USAGE: euler(r);
    216 RETURN: number phi(r), where phi is Eulers phi-function
     216RETURN: bigint phi(r), where phi is Eulers phi-function
    217217NOTE:   first r is factorized with proc PollardRho, then phi(r) is
    218218        calculated with the help of phi(p) of every factor p;
     
    222222  list l=PollardRho(r,5000,1);           //bestimmen der Primfaktoren von r
    223223  int k;
    224   number phi=r;
     224  bigint phi=r;
    225225  for(k=1;k<=size(l);k++)
    226226  {
    227     phi=phi-phi/l[k];       //berechnen phi(r) mit Hilfe der
     227    phi=phi-phi div l[k];       //berechnen phi(r) mit Hilfe der
    228228  }                         //Primfaktoren und Eigenschaften der phi-Fktn
    229229  return(phi);
     
    231231example
    232232{ "EXAMPLE:"; echo = 2;
    233    ring R = 0,x,dp;
    234233   euler(99991);
    235234}
  • Singular/LIB/atkins.lib

    r38a53c0 r2fede6  
    1 //////////////////////////////////////////////////////////////////////////////
    2 version="version atkins.lib 4.0.0.0 Jun_2013 "; // $Id$
     1///////////////////////////////////////////////////////////////////////////////
     2version="version atkins.lib 4.0.0.0 Jun_2014 ";
    33category="Teaching";
    44info="
     
    133133
    134134
    135 proc Cornacchia(number d, number p)
     135proc Cornacchia(bigint d, bigint p)
    136136"USAGE: Cornacchia(d,p);
    137137RETURN: x,y such that x^2+d*y^2=p with p prime,
     
    149149  else
    150150  {
    151     number k,x(0),a,b,l,r,c,i;
     151    bigint k,x(0),a,b,l,r,c,i;
    152152
    153153    k=Jacobi(-d,p);             // (1)[Test if residue]
     
    160160    {
    161161       x(0)=squareRoot(-d,p);   // (2)[Compute square root]
    162        if((p/2>=x(0))||(p<=x(0)))
     162       if((p div 2>=x(0))||(p<=x(0)))
    163163       {
    164164           x(0)=-x(0) mod p+p;
     
    173173          b=r;
    174174       }
    175        c=(p-b^2)/d;             // (4)[Test solution]
     175       c=(p-b^2) div d;             // (4)[Test solution]
    176176       i=intRoot(c);
    177177       if((((p-b^2) mod d)!=0)||(c!=i^2))
     
    189189example
    190190{ "EXAMPLE:"; echo = 2;
    191     ring R = 0,x,dp;
    192191    Cornacchia(55,9551);
    193192}
    194193
    195194
    196 proc CornacchiaModified(number D, number p)
     195proc CornacchiaModified(bigint D, bigint p)
    197196"USAGE: CornacchiaModified(D,p);
    198197RETURN: x,y such that x^2+|D|*y^2=p with p prime,
     
    224223    else
    225224    {
    226       number k,x(0),a,b,l,r,c;
     225      bigint k,x(0),a,b,l,r,c;
    227226      k=Jacobi(D,p);                 // (2)[Test if residue]
    228227      if(k==-1)
     
    247246          b=r;
    248247        }
    249         c=(4*p-b^2)/absValue(D);     // (5)[Test solution]
    250         number root_c=intRoot(c);
     248        c=(4*p-b^2) div absValue(D);     // (5)[Test solution]
     249        bigint root_c=intRoot(c);
    251250        if((((4*p-b^2) mod absValue(D))!=0)||(c!=root_c^2))
    252251        {
     
    265264example
    266265{ "EXAMPLE:"; echo = 2;
    267     ring R = 0,x,dp;
    268266    CornacchiaModified(-107,1319);
    269267}
    270268
    271269
    272 proc pFactor1(number n,int B, list P)
     270static proc pFactor1(number n,int B, list P)
    273271"USAGE: pFactor1(n,B,P); n to be factorized, B a bound , P a list of primes
    274272RETURN: a list of factors of n or the message: no factor found
     
    517515
    518516
    519 proc HilbertClassPoly(number D, int k)
     517proc HilbertClassPoly(bigint D, int k)
    520518"USAGE: HilbertClassPoly(D,k);
    521519RETURN: the monic polynomial of degree h(D) in Z[X] of which jOft((D+sqr(D))/2) is a root
     
    534532  {
    535533    def S=basering;
    536     ring R=0,x,dp;
    537534
    538535    string s1,s2,s3;
    539     number a1,b1,t1,g1;
    540     number D=imap(S,D);
    541     number B=intRoot(absValue(D)/3);
     536    bigint B=intRoot(absValue(D) div 3);
    542537
    543538    ring C=(complex,10*k,i),x,dp;
    544     number D=imap(S,D);
     539    number DD=D;
    545540
    546541    poly P=1;                  // (1)[Initialize]
    547     number b=cmod(D,2);
    548     number B=imap(R,B);
     542    number b=cmod(DD,2);
    549543
    550544    number t,a,g,tau,j;
    551545    list L;
    552546
     547    bigint a1,b1,t1,g1;
    553548    int step=2;
    554549    while(1)
     
    556551      if(step==2)              // (2)[Initialize a]
    557552      {
    558         t=(b^2-D)/4;
     553        t=(b^2-DD)/4;
    559554        L=b,1;
    560555        a=maximum(L);
     
    574569          s3=string(t);
    575570
    576           setring R;
    577571          execute("a1="+s1+";");
    578572          execute("b1="+s2+";");
    579573          execute("t1="+s3+";");
    580           g1=gcd(gcd(a1,b1),t1/a1);
     574          g1=gcd(gcd(a1,b1),t1 div a1);
    581575          setring C;
    582           g=imap(R,g1);
     576          g=g1;
    583577
    584578          if(g!=1)
     
    588582          else
    589583          {
    590             tau=(-b+i*sqr(absValue(D),5*k))/(2*a);
     584            tau=(-b+i*sqr(absValue(DD),5*k))/(2*a);
    591585            j=jOft(tau,k);
    592586            if((a==b)||(a^2==t)||(b==0))
     
    657651{ "EXAMPLE:"; echo = 2;
    658652    ring r = 0,x,dp;
    659     number D=-23;
     653    bigint D=-23;
    660654    HilbertClassPoly(D,50);
    661655}
     
    713707      ring T=0,var(1),dp;
    714708      number d=imap(R,d);
    715       number e=squareRoot(d,p);
     709      number e=squareRoot(bigint(d),bigint(p));
    716710      setring R;
    717711      number e=imap(T,e);
  • Singular/LIB/crypto.lib

    r38a53c0 r2fede6  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="version crypto.lib 4.0.0.0 Jun_2013 "; // $Id$
     2version="version crypto.lib 4.0.0.0 Jun_2014 "; // $Id$
    33category="Teaching";
    44info="
     
    1616PROCEDURES:
    1717 decimal(s);                number corresponding to the hexadecimal number s
    18  exgcdN(a,n)                compute s,t,d such that d=gcd(a,n)=s*a+t*n
    1918 eexgcdN(L)                 T with sum_i L[i]*T[i]=T[n+1]=gcd(L[1],...,L[n])
    20  gcdN(a,b)                  compute gcd(a,b)
    2119 lcmN(a,b)                  compute lcm(a,b)
    2220 powerN(m,d,n)              compute m^d mod n
     
    10199}
    102100
    103 proc exgcdN(number a, number n)
    104 "USAGE:  exgcdN(a,n);
    105 RETURN: a list s,t,d of numbers satisfying d=gcd(a,n)=s*a+t*n
    106 EXAMPLE:example exgcdN; shows an example
    107 "
    108 {
    109   number x=a mod n;
    110   if(x==0){return(list(0,1,n))}
    111   if (x<0) { x=x+n;}
    112   list l=exgcdN(n,x);
    113   return(list(l[2],l[1]-(a-x)*l[2]/n,l[3]))
    114 }
    115 example
    116 { "EXAMPLE:"; echo = 2;
    117    ring R = 0,x,dp;
    118    exgcdN(24,15);
    119 }
    120 
    121101proc eexgcdN(list L)
    122102"USAGE:  eexgcdN(L);
     
    125105"
    126106{
    127    if(size(L)==2){return(exgcdN(L[1],L[2]));}
    128    number p=L[size(L)];
     107   if(size(L)==2)
     108   {
     109     list LL=extgcd(L[1],L[2]);return(list(LL[2],LL[3],LL[1]));
     110   }
     111   bigint p=L[size(L)];
    129112   L=delete(L,size(L));
    130113   list T=eexgcdN(L);
    131    list S=exgcdN(T[size(T)],p);
     114   list S=extgcd(T[size(T)],p);
    132115   int i;
    133116   for(i=1;i<=size(T)-1;i++)
    134117   {
    135       T[i]=T[i]*S[1];
     118      T[i]=T[i]*S[2];
    136119   }
    137120   p=T[size(T)];
    138    T[size(T)]=S[2];
    139    T[size(T)+1]=S[3];
     121   T[size(T)]=S[3];
     122   T[size(T)+1]=S[1];
    140123   return(T);
    141124}
    142125example
    143126{ "EXAMPLE:"; echo = 2;
    144    ring R = 0,x,dp;
    145127   eexgcdN(list(24,15,21));
    146128}
    147129
    148 proc gcdN(number a, number b)
    149 "USAGE:  gcdN(a,b);
    150 RETURN: gcd(a,b)
    151 EXAMPLE:example gcdN; shows an example
    152 "
    153 {
    154    //if((a mod b)==0){return(b)}
    155    //return(gcdN(b,a mod b));
    156    return(gcd(a,b));
    157 }
    158 example
    159 { "EXAMPLE:"; echo = 2;
    160    ring R = 0,x,dp;
    161    gcdN(24,15);
    162 }
    163 
    164 proc lcmN(number a, number b)
     130proc lcmN(bigint a, bigint b)
    165131"USAGE:  lcmN(a,b);
    166132RETURN: lcm(a,b);
     
    168134"
    169135{
    170    //number d=gcdN(a,b);
    171    //return(a*b/d);
    172136   return (a*b/gcd(a,b));
    173137}
    174138example
    175139{ "EXAMPLE:"; echo = 2;
    176    ring R = 0,x,dp;
    177140   lcmN(24,15);
    178141}
    179142
    180 proc powerN(number m, number d, number n)
     143proc powerN(bigint m, bigint d, bigint n)
    181144"USAGE:  powerN(m,d,n);
    182145RETURN: m^d mod n
     
    184147"
    185148{
    186    if(d==0){return(1);}
     149   if(d==0){return(bigint(1));}
    187150   int i;
    188151   if(n==0)
     
    190153      for(i=12;i>=2;i--)
    191154      {
    192          if((d mod i)==0){return(powerN(m,d/i,n)^i);}
     155         if((d mod i)==0){return(powerN(m,d div i,n)^i);}
    193156      }
    194157      return(m*powerN(m,d-1,n));
     
    198161      if((d mod i)==0)
    199162      {
    200         number rr=powerN(m,d/i,n)^i mod n;
     163        bigint rr=powerN(m,d div i,n)^i mod n;
    201164        if (rr<0) { rr=rr+n;}
    202165        return(rr);
     
    207170example
    208171{ "EXAMPLE:"; echo = 2;
    209    ring R = 0,x,dp;
    210172   powerN(24,15,7);
    211173}
     
    220182   int i;
    221183   int n=size(L);
    222    number N=1;
     184   bigint N=1;
    223185   for(i=1;i<=n;i++)
    224186   {
     
    228190   for(i=1;i<=n;i++)
    229191   {
    230       M[i]=N/L[i];
     192      M[i]=N div L[i];
    231193   }
    232194   list S=eexgcdN(M);
    233    number x;
     195   bigint x;
    234196   for(i=1;i<=n;i++)
    235197   {
     
    241203example
    242204{ "EXAMPLE:"; echo = 2;
    243    ring R = 0,x,dp;
    244205   chineseRem(list(24,15,7),list(2,3,5));
    245206}
    246207
    247 proc Jacobi(number a, number n)
     208proc Jacobi(bigint a, bigint n)
    248209"USAGE:  Jacobi(a,n);
    249210RETURN: the generalized Legendre symbol
     
    254215   int i;
    255216   int z=1;
    256    number t=1;
    257    number k;
     217   bigint t=1;
     218   bigint k;
    258219
    259220   if((((n-1)/2) mod 2)!=0){z=-1;}
     
    267228      while((a mod 2)==0)
    268229      {
    269          a=a/2;
     230         a=a div 2;
    270231         if(((n mod 8)==3)||((n mod 8)==5)){t=-t;}
    271232      }
     
    279240example
    280241{ "EXAMPLE:"; echo = 2;
    281    ring R = 0,x,dp;
    282242   Jacobi(13580555397810650806,5792543);
    283243}
     
    312272}
    313273
    314 proc primL(number q)
     274proc primL(bigint q)
    315275"USAGE:  primL(q);
    316276RETURN: list of the first primes p_1,...,p_r such that q>p_1*...*p_(r-1)
     
    323283   re[1]=2;
    324284   re[2]=3;
    325    number s=6;
     285   bigint s=6;
    326286   i=3;
    327287   while(s<=q)
     
    344304example
    345305{ "EXAMPLE:"; echo = 2;
    346    ring R = 0,x,dp;
    347306   primL(20);
    348307}
     
    356315  if (x>=0)
    357316  {
    358     return((numerator(x)-(numerator(x) mod denominator(x)))/denominator(x));
     317    return(bigint((numerator(x)-(bigint(numerator(x)) mod bigint(denominator(x)))))
     318         div bigint(denominator(x)));
    359319  }
    360320  else
    361321  {
    362     return((numerator(x)-(numerator(x) mod denominator(x)+denominator(x)))/denominator(x));
     322    return(bigint((numerator(x)-(bigint(numerator(x)) mod bigint(denominator(x)+denominator(x)))))
     323         div bigint(denominator(x)));
    363324  }
    364325}
    365326example
    366327{ "EXAMPLE:"; echo = 2;
    367    ring R = 0,x,dp;
     328   ring r=0,x,dp;
    368329   intPart(7/3);
    369330}
    370331
    371 proc intRoot(number m)
     332proc intRoot(bigint mm)
    372333"USAGE:  intRoot(m);
    373334RETURN: the integral part of the square root of m
     
    375336"
    376337{
     338   ring R = 0,@x,dp;
     339   number m=mm;
    377340   number x=1;
    378341   number t=x^2;
     
    395358      }
    396359   }
    397    if(t>m){return(x-1);}
    398    if(s==m){return(x+1);}
    399    return(x);
    400 }
    401 example
    402 { "EXAMPLE:"; echo = 2;
    403    ring R = 0,x,dp;
     360   if(t>m){return(bigint(x-1));}
     361   if(s==m){return(bigint(x+1));}
     362   return(bigint(x));
     363}
     364example
     365{ "EXAMPLE:"; echo = 2;
    404366   intRoot(20);
    405367}
    406368
    407 proc squareRoot(number a, number p)
     369proc squareRoot(bigint a, bigint p)
    408370"USAGE:  squareRoot(a,p);
    409371RETURN: the square root of a in Z/p, p prime
     
    418380   {
    419381      "p is not prime";
    420       return(number(-5));
    421    }
    422    number n=random(1,2147483647) mod p;
     382      return(bigint(-5));
     383   }
     384   bigint n=random(1,2147483647) mod p;
    423385   if(n==0){n=n+1;}
    424    number j=Jacobi(n,p);
     386   bigint j=Jacobi(n,p);
    425387   if(j==0)
    426388   {
    427389      "p is not prime";
    428       return(number(-5));
     390      return(bigint(-5));
    429391   }
    430392   if(j==1)
     
    432394      return(squareRoot(a,p));
    433395   }
    434    number q=p-1;
    435    number e=0;
    436    number two=2;
    437    number z,m,t;
     396   bigint q=p-1;
     397   bigint e=0;
     398   bigint two=2;
     399   bigint z,m,t;
    438400   while((q mod 2)==0)
    439401   {
    440402      e=e+1;
    441       q=q/2;
    442    }
    443    number y=powerN(n,q,p);
    444    number r=e;
    445    number x=powerN(a,(q-1)/2,p);
    446    number b=a*x^2 mod p;
     403      q=q div 2;
     404   }
     405   bigint y=powerN(n,q,p);
     406   bigint r=e;
     407   bigint x=powerN(a,(q-1) div 2,p);
     408   bigint b=a*x^2 mod p;
    447409   x=a*x mod p;
    448410
     
    465427example
    466428{ "EXAMPLE:"; echo = 2;
    467    ring R = 0,x,dp;
    468429   squareRoot(8315890421938608,32003);
    469430}
    470431
    471432
    472 proc solutionsMod2(matrix M)
     433proc solutionsMod2(bigintmat MM)
    473434"USAGE:  solutionsMod2(M);
    474435RETURN: an intmat containing a basis of the vector space of solutions of the
     
    478439"
    479440{
    480    def R=basering;
    481441   ring Rhelp=2,z,(c,dp);
    482    matrix M=imap(R,M);
     442   int i,j;
     443   matrix M[nrows(MM)][ncols(MM)];
     444   for(i=1;i<=nrows(MM);i++)
     445   {
     446      for(j=1;j<=ncols(MM);j++)
     447      {
     448         M[i,j]=MM[i,j];
     449      }
     450   }
    483451   matrix S=syz(M);
    484    setring(R);
    485    matrix S=imap(Rhelp,S);
    486    int i,j;
    487452   intmat v[nrows(S)][ncols(S)];
    488453   for(i=1;i<=nrows(S);i++)
     
    497462example
    498463{ "EXAMPLE:"; echo = 2;
    499    ring R = 0,x,dp;
    500    matrix M[3][3]=1,2,3,4,5,6,7,6,5;
     464   bigintmat M[3][3]=1,2,3,4,5,6,7,6,5;
    501465   solutionsMod2(M);
    502466}
     
    528492//============== Shank's baby step - giant step ========================
    529493
    530 proc babyGiant(number b, number y, number p)
     494proc babyGiant(bigint b, bigint y, bigint p)
    531495"USAGE:  babyGiant(b,y,p);
    532496RETURN: the discrete logarithm x: b^x=y mod p
     
    537501   int i,j,m;
    538502   list l;
    539    number h=1;
    540    number x;
     503   bigint h=1;
     504   bigint x;
    541505
    542506//choose m minimal such that m^2>p
     
    549513//giant-step: compute b^(m+j), 1<=j<=m and search in the baby-step table
    550514//for an i with y*b^i=b^(m*j). If found then x=m*j-i
    551    number g=b^m mod p;
     515   bigint g=b^m mod p;
    552516   while(j<m)
    553517   {
     
    568532example
    569533{ "EXAMPLE:"; echo = 2;
    570    ring R = 0,z,dp;
    571    number b=2;
    572    number y=10;
    573    number p=101;
     534   bigint b=2;
     535   bigint y=10;
     536   bigint p=101;
    574537   babyGiant(b,y,p);
    575538}
     
    577540//==============  Pollards rho  =================================
    578541
    579 proc rho(number b, number y, number p)
     542proc rho(bigint b, bigint y, bigint p)
    580543"USAGE:  rho(b,y,p);
    581544RETURN: the discrete logarithm x=log_b(y): b^x=y mod p
     
    591554   int i=1;
    592555   int j;
    593    number s,t;
     556   bigint s,t;
    594557   list e,f,x;
    595558
     
    640603   }
    641604
    642    list w=exgcdN(s,p-1);
    643    number u=w[1];
    644    number d=w[3];
    645 
    646    number a=(t*u/d) mod (p-1);
    647 
    648    number pn=powerN(b,a,p);
     605   list w=extgcd(s,p-1);
     606   bigint u=w[2];
     607   bigint d=w[1];
     608
     609   bigint a=(t*u div d) mod (p-1);
     610
     611   bigint pn=powerN(b,a,p);
    649612   if (pn<0) { pn=pn+p;}
    650613   while(powerN(b,a,p)!=y)
    651614   {
    652       a=(a+(p-1)/d) mod (p-1);
     615      a=(a+(p-1) div d) mod (p-1);
    653616      if (a<0) { a=a+p-1; }
    654617   }
     
    657620example
    658621{ "EXAMPLE:"; echo = 2;
    659    ring R = 0,x,dp;
    660    number b=2;
    661    number y=10;
    662    number p=101;
     622   bigint b=2;
     623   bigint y=10;
     624   bigint p=101;
    663625   rho(b,y,p);
    664626}
     
    669631//================================= Miller-Rabin =====================
    670632
    671 proc MillerRabin(number n, int k)
     633proc MillerRabin(bigint n, int k)
    672634"USAGE:  MillerRabin(n,k);
    673635RETURN: 1 if n is prime, 0 else
     
    683645
    684646   int i;
    685    number a,b,j,r,s;
     647   bigint a,b,j,r,s;
    686648   r=n-1;
    687649   s=0;
     
    689651   {
    690652      s=s+1;
    691       r=r/2;
     653      r=r div 2;
    692654   }
    693655   while(i<k)
     
    695657      i++;
    696658      a=random(2,2147483629) mod n; if(a==0){a=3;}
    697       if(exgcdN(a,n)[3]!=1){return(0);}
     659      if(gcd(a,n)!=1){return(0);}
    698660      b=powerN(a,r,n);
    699661      if(b!=1)
     
    713675example
    714676{ "EXAMPLE:"; echo = 2;
    715    ring R = 0,z,dp;
    716    number x=2;
     677   bigint x=2;
    717678   x=x^787-1;
    718679   MillerRabin(x,3);
     
    721682//======================= Soloway-Strassen  ==========================
    722683
    723 proc SolowayStrassen(number n, int k)
     684proc SolowayStrassen(bigint n, int k)
    724685"USAGE:  SolowayStrassen(n,k);
    725686RETURN: 1 if n is prime, 0 else
     
    734695   if((n mod 2)==0){return(0);}
    735696
    736    number a,pn,jn;
     697   bigint a,pn,jn;
    737698   int i;
    738699   while(i<k)
     
    741702      a=random(2,2147483629) mod n; if(a==0){a=3;}
    742703      if(gcd(a,n)!=1){return(0);}
    743       pn=powerN(a,(n-1)/2,n);
     704      pn=powerN(a,(n-1) div 2,n);
    744705      if (pn<0) { pn=pn+n;}
    745706      jn=Jacobi(a,n) mod n;
     
    751712example
    752713{ "EXAMPLE:"; echo = 2;
    753    ring R = 0,z,dp;
    754    number h=10;
    755    number p=h^100+267;
     714   bigint h=10;
     715   bigint p=h^100+267;
    756716   //p=h^100+43723;
    757717   //p=h^200+632347;
     
    770730//===================== Pocklington-Lehmer ==============================
    771731
    772 proc PocklingtonLehmer(number N, list #)
     732proc PocklingtonLehmer(bigint N, list #)
    773733"USAGE: PocklingtonLehmer(N); optional: PocklingtonLehmer(N,L);
    774734        L a list of the first k primes
     
    781741"
    782742{
    783    number m=intRoot(N);
     743   bigint m=intRoot(N);
    784744   if(size(#)>0)
    785745   {
     
    791751   }
    792752   int i,j;
    793    number A=1;
    794    number p,a,g;
     753   bigint A=1;
     754   bigint p,a,g;
    795755   list PA;
    796756   list re;
     
    819779   if(A<=m)
    820780   {
    821      A=N/A;
     781     A=N div A;
    822782     PA=list(S[size(S)]);
    823783   }
     
    829789         a=a+1;
    830790         if(powerN(a,N-1,N)!=1){return("not prime");}
    831          g=gcd(powerN(a,(N-1)/PA[i],N),N);
     791         g=gcd(powerN(a,(N-1) div PA[i],N),N);
    832792         if(g==1)
    833793         {
     
    842802example
    843803{ "EXAMPLE:"; echo = 2;
    844    ring R = 0,z,dp;
    845    number N=105554676553297;
     804   bigint N=105554676553297;
    846805   PocklingtonLehmer(N);
    847806   list L=primList(1000);
     
    855814//======================= Pollards rho  =================================
    856815
    857 proc PollardRho(number n, int k, int allFactors, list #)
     816proc PollardRho(bigint n, int k, int allFactors, list #)
    858817"USAGE:  PollardRho(n,k,allFactors); optional: PollardRho(n,k,allFactors,L);
    859818         L a list of the first k primes
     
    888847          while((n mod L[i])==0)
    889848          {
    890              n=n/L[i];
     849             n=n div L[i];
    891850          }
    892851       }
     
    895854    int e=size(re);
    896855//here the rho-algorithm starts
    897     number a,d,x,y;
     856    bigint a,d,x,y;
    898857    while(n>1)
    899858    {
     
    915874             while((n mod d)==0)
    916875             {
    917                n=n/d;
     876               n=n div d;
    918877             }
    919878             break;
     
    949908example
    950909{ "EXAMPLE:"; echo = 2;
    951    ring R = 0,z,dp;
    952    number h=10;
    953    number p=h^30+4;
     910   bigint h=10;
     911   bigint p=h^30+4;
    954912   PollardRho(p,5000,0);
    955913}
    956914
    957915//======================== Pollards p-factorization ================
    958 proc pFactor(number n,int B, list P)
     916proc pFactor(bigint n,int B, list P)
    959917"USAGE:  pFactor(n,B,P); n to be factorized, B a bound , P a list of primes
    960918RETURN: a list of factors of n or n if no factor found
     
    967925{
    968926   int i;
    969    number k=1;
    970    number w;
     927   bigint k=1;
     928   bigint w;
    971929   while(i<size(P))
    972930   {
     
    980938      k=k*w;
    981939   }
    982    number a=random(2,2147483629);
    983    number d=gcd(powerN(a,k,n)-1,n);
     940   bigint a=random(2,2147483629);
     941   bigint d=gcd(powerN(a,k,n)-1,n);
    984942   if((d>1)&&(d<n)){return(d);}
    985943   return(n);
     
    987945example
    988946{ "EXAMPLE:"; echo = 2;
    989    ring R = 0,z,dp;
    990947   list L=primList(1000);
    991948   pFactor(1241143,13,L);
    992    number h=10;
     949   bigint h=10;
    993950   h=h^30+25;
    994951   pFactor(h,20,L);
     
    997954//==================== quadratic sieve ==============================
    998955
    999 proc quadraticSieve(number n, int c, list B, int k)
     956proc quadraticSieve(bigint n, int c, list B, int k)
    1000957"USAGE:  quadraticSieve(n,c,B,k); n to be factorized, [-c,c] the
    1001958         sieve-intervall, B a list of primes,
     
    1007964"
    1008965{
    1009    number f,d;
     966   bigint f,d;
    1010967   int i,j,l,s,p;
    1011968   list S,tmp;
     
    1014971
    1015972//compute the integral part of the square root of n
    1016    number m=intRoot(n);
     973   bigint m=intRoot(n);
    1017974
    1018975//consider the function f(X)=(X+m)^2-n and compute for s in [-c,c] the values
     
    10461003         {
    10471004            s++;
    1048             f=f/p;
     1005            f=f div p;
    10491006         }
    10501007         if(s)
     
    10631020              {
    10641021                s++;
    1065                 f=f/p;
     1022                f=f div p;
    10661023              }
    10671024              S[l][2]=f;
     
    10841041//the system of equations for the exponents {l_s} for the f(s) such
    10851042//product f(s)^l_s is a square (l_s are 1 or 0)
    1086    matrix M[k+1][size(T)];
     1043   bigintmat M[k+1][size(T)];
    10871044   for(j=1;j<=size(T);j++)
    10881045   {
     
    10981055//y=square root of product f(s)^l_s
    10991056//x=product s+m
    1100    number x=1;
    1101    number y=1;
     1057   bigint x=1;
     1058   bigint y=1;
    11021059
    11031060   for(i=1;i<=ncols(G);i++)
     
    11241081example
    11251082{ "EXAMPLE:"; echo = 2;
    1126    ring R = 0,z,dp;
    11271083   list L=primList(5000);
    11281084   quadraticSieve(7429,3,L,4);
     
    11361092//================= elementary operations ==============================
    11371093
    1138 proc isOnCurve(number N, number a, number b, list P)
     1094proc isOnCurve(bigint N, bigint a, bigint b, list P)
    11391095"USAGE:  isOnCurve(N,a,b,P);
    11401096RETURN: 1 or 0 (depending on whether P is on the curve or not)
     
    11491105example
    11501106{ "EXAMPLE:"; echo = 2;
    1151    ring R = 0,z,dp;
    11521107   isOnCurve(32003,5,7,list(10,16,1));
    11531108}
    11541109
    1155 proc ellipticAdd(number N, number a, number b, list P, list Q)
     1110proc ellipticAdd(bigint N, bigint a, bigint b, list P, list Q)
    11561111"USAGE:  ellipticAdd(N,a,b,P,Q);
    11571112RETURN: list L, representing the point P+Q
     
    11691124   }
    11701125   list Resu;
    1171    Resu[1]=number(0);
    1172    Resu[2]=number(1);
    1173    Resu[3]=number(0);
     1126   Resu[1]=bigint(0);
     1127   Resu[2]=bigint(1);
     1128   Resu[3]=bigint(0);
    11741129   list Error;
    11751130   Error[1]=0;
    11761131   //test for ellictic curve
    1177    number D=4*a^3+27*b^2;
    1178    number g=gcd(D,N);
     1132   bigint D=4*a^3+27*b^2;
     1133   bigint g=gcd(D,N);
    11791134   if(g==N){return(Error);}
    11801135   if(g!=1)
     
    11951150   if(P[3]==0){return(Q);}
    11961151   if(Q[3]==0){return(P);}
    1197    list I=exgcdN(P[3],N);
    1198    if(I[3]!=1)
    1199    {
    1200       P[4]=I[3];
     1152   list I=extgcd(P[3],N);
     1153   if(I[1]!=1)
     1154   {
     1155      P[4]=I[1];
    12011156      return(P);
    12021157   }
    1203    P[1]=P[1]*I[1] mod N;
    1204    P[2]=P[2]*I[1] mod N;
    1205    I=exgcdN(Q[3],N);
    1206    if(I[3]!=1)
    1207    {
    1208       P[4]=I[3];
     1158   P[1]=P[1]*I[2] mod N;
     1159   P[2]=P[2]*I[2] mod N;
     1160   I=extgcd(Q[3],N);
     1161   if(I[1]!=1)
     1162   {
     1163      P[4]=I[1];
    12091164      return(P);
    12101165   }
    1211    Q[1]=Q[1]*I[1] mod N;
    1212    Q[2]=Q[2]*I[1] mod N;
     1166   Q[1]=Q[1]*I[2] mod N;
     1167   Q[2]=Q[2]*I[2] mod N;
    12131168   if((P[1]==Q[1])&&(((P[2]+Q[2]) mod N)==0)){return(Resu);}
    1214    number L;
     1169   bigint L;
    12151170   if((P[1]==Q[1])&&(P[2]==Q[2]))
    12161171   {
    1217       I=exgcdN(2*Q[2],N);
    1218       if(I[3]!=1)
    1219       {
    1220          P[4]=I[3];
     1172      I=extgcd(2*Q[2],N);
     1173      if(I[1]!=1)
     1174      {
     1175         P[4]=I[1];
    12211176         return(P);
    12221177      }
    1223       L=I[1]*(3*Q[1]^2+a) mod N;
     1178      L=I[2]*(3*Q[1]^2+a) mod N;
    12241179   }
    12251180   else
    12261181   {
    1227       I=exgcdN(Q[1]-P[1],N);
    1228       if(I[3]!=1)
    1229       {
    1230          P[4]=I[3];
     1182      I=extgcd(Q[1]-P[1],N);
     1183      if(I[1]!=1)
     1184      {
     1185         P[4]=I[1];
    12311186         return(P);
    12321187      }
    1233       L=(Q[2]-P[2])*I[1] mod N;
     1188      L=(Q[2]-P[2])*I[2] mod N;
    12341189   }
    12351190   Resu[1]=(L^2-P[1]-Q[1]) mod N;
     
    12371192   Resu[2]=(L*(P[1]-Resu[1])-P[2]) mod N;
    12381193   if (Resu[2]<0) { Resu[2]=Resu[2]+N; }
    1239    Resu[3]=number(1);
     1194   Resu[3]=bigint(1);
    12401195   return(Resu);
    12411196}
    12421197example
    12431198{ "EXAMPLE:"; echo = 2;
    1244    ring R = 0,z,dp;
    1245    number N=11;
    1246    number a=1;
    1247    number b=6;
     1199   bigint N=11;
     1200   bigint a=1;
     1201   bigint b=6;
    12481202   list P,Q;
    12491203   P[1]=2;
     
    12561210}
    12571211
    1258 proc ellipticMult(number N, number a, number b, list P, number k)
     1212proc ellipticMult(bigint N, bigint a, bigint b, list P, bigint k)
    12591213"USAGE:  ellipticMult(N,a,b,P,k);
    12601214RETURN: a list L representing the point k*P
     
    12661220   if(P[3]==0){return(P);}
    12671221   list resu;
    1268    resu[1]=number(0);
    1269    resu[2]=number(1);
    1270    resu[3]=number(0);
     1222   resu[1]=bigint(0);
     1223   resu[2]=bigint(1);
     1224   resu[3]=bigint(0);
    12711225
    12721226   if(k==0){return(resu);}
     
    12941248example
    12951249{ "EXAMPLE:"; echo = 2;
    1296    ring R = 0,z,dp;
    1297    number N=11;
    1298    number a=1;
    1299    number b=6;
     1250   bigint N=11;
     1251   bigint a=1;
     1252   bigint b=6;
    13001253   list P;
    13011254   P[1]=2;
     
    13071260//================== Random for elliptic curves =====================
    13081261
    1309 proc ellipticRandomCurve(number N)
     1262proc ellipticRandomCurve(bigint N)
    13101263"USAGE:  ellipticRandomCurve(N);
    13111264RETURN: a list of two random numbers a,b and 4a^3+27b^2 mod N
     
    13181271   {
    13191272     k++;
    1320      number a=random(1,2147483647) mod N;
    1321      number b=random(1,2147483647) mod N;
     1273     bigint a=random(1,2147483647) mod N;
     1274     bigint b=random(1,2147483647) mod N;
    13221275     //test for ellictic curve
    1323      number D=4*a^3+27*b^4; //the constant term is b^2
    1324      number g=gcd(D,N);
     1276     bigint D=4*a^3+27*b^4; //the constant term is b^2
     1277     bigint g=gcd(D,N);
    13251278     if(g<N){return(list(a,b,g));}
    13261279   }
     
    13291282example
    13301283{ "EXAMPLE:"; echo = 2;
    1331    ring R = 0,z,dp;
    13321284   ellipticRandomCurve(32003);
    13331285}
    13341286
    1335 proc ellipticRandomPoint(number N, number a, number b)
     1287proc ellipticRandomPoint(bigint N, bigint a, bigint b)
    13361288"USAGE:  ellipticRandomPoint(N,a,b);
    13371289RETURN: a list representing  a random point (x:y:z) of the elliptic curve
     
    13401292"
    13411293{
    1342    number x=random(1,2147483647) mod N;
    1343    number h=x^3+a*x+b;
     1294   bigint x=random(1,2147483647) mod N;
     1295   bigint h=x^3+a*x+b;
    13441296   h=h mod N;
    13451297   list resu;
     
    13491301   if(h==0){return(resu);}
    13501302
    1351    number n=Jacobi(h,N);
     1303   bigint n=Jacobi(h,N);
    13521304   if(n==0)
    13531305   {
     
    13651317example
    13661318{ "EXAMPLE:"; echo = 2;
    1367    ring R = 0,z,dp;
    13681319   ellipticRandomPoint(32003,3,181);
    13691320}
     
    13761327
    13771328//==================   the trivial approaches  =======================
    1378 proc countPoints(number N, number a, number b)
     1329proc countPoints(bigint N, bigint a, bigint b)
    13791330"USAGE:  countPoints(N,a,b);
    13801331RETURN: the number of points of the elliptic curve defined by
     
    13841335"
    13851336{
    1386   number x;
    1387   number r=N+1;
     1337  bigint x;
     1338  bigint r=N+1;
    13881339  while(x<N)
    13891340  {
     
    13951346example
    13961347{ "EXAMPLE:"; echo = 2;
    1397    ring R = 0,z,dp;
    13981348   countPoints(181,71,150);
    13991349}
    14001350
    1401 proc ellipticAllPoints(number N, number a, number b)
     1351proc ellipticAllPoints(bigint N, bigint a, bigint b)
    14021352"USAGE:  ellipticAllPoints(N,a,b);
    14031353RETURN: list of points (x:y:z) of the elliptic curve defined by
     
    14121362   resu[1]=point;
    14131363   point[3]=1;
    1414    number x,h,n;
     1364   bigint x,h,n;
    14151365   while(x<N)
    14161366   {
     
    14411391example
    14421392{ "EXAMPLE:"; echo = 2;
    1443    ring R = 0,z,dp;
    14441393   list L=ellipticAllPoints(181,71,150);
    14451394   size(L);
     
    14491398//================ the algorithm of Shanks and Mestre =================
    14501399
    1451 proc ShanksMestre(number q, number a, number b, list #)
     1400proc ShanksMestre(bigint q, bigint a, bigint b, list #)
    14521401"USAGE:  ShanksMestre(q,a,b); optional: ShanksMestre(q,a,b,s); s the number
    14531402         of loops in the algorithm (default s=1)
     
    14581407"
    14591408{
    1460    number n=intRoot(4*q);
    1461    number m=intRoot(intRoot(16*q))+1;
    1462    number d;
     1409   bigint n=intRoot(4*q);
     1410   bigint m=intRoot(intRoot(16*q))+1;
     1411   bigint d;
    14631412   int i,j,k,s;
    14641413   list B,K,T,P,Q,R,mP;
     
    14921441            if((Q[1]==B[j][1])&&(Q[2]==B[j][2])&&(Q[3]==B[j][3]))
    14931442            {
    1494 
    14951443               T[1]=P;
    14961444               T[2]=q+1+n-(i*m+j-1);
     
    15391487example
    15401488{ "EXAMPLE:"; echo = 2;
    1541    ring R = 0,z,dp;
    15421489   ShanksMestre(32003,71,602);
    15431490}
     
    15451492//==================== Schoof's algorithm =============================
    15461493
    1547 proc Schoof(number N,number a, number b)
     1494proc Schoof(bigint N,bigint a, bigint b)
    15481495"USAGE:  Schoof(N,a,b);
    15491496RETURN: the number of points of the elliptic curve defined by
     
    15551502   int pr=printlevel;
    15561503//test for ellictic curve
    1557    number D=4*a^3+27*b^2;
    1558    number G=gcd(D,N);
     1504   bigint D=4*a^3+27*b^2;
     1505   bigint G=gcd(D,N);
    15591506   if(G==N){ERROR("not an elliptic curve");}
    15601507   if(G!=1){ERROR("not a prime");}
     
    15641511
    15651512//=== the general case
    1566    number q=intRoot(4*N);
     1513   bigint q=intRoot(4*N);
    15671514   list L=primL(2*q);
    15681515   int r=size(L);
     
    15861533      "===================================================================";
    15871534   }
    1588    number t=chineseRem(T,L)-q;
     1535   bigint t=chineseRem(T,L)-q;
    15891536   return(N+1-t);
    15901537}
    15911538example
    15921539{ "EXAMPLE:"; echo = 2;
    1593    ring R = 0,z,dp;
    15941540   Schoof(32003,71,602);
    15951541}
     
    16381584
    16391585
    1640 proc testElliptic(int q,number a,number b,int l)
     1586static proc testElliptic(int q,bigint aa,bigint bb,int l)
    16411587"USAGE:  testElliptic(q,a,b,l);
    16421588RETURN: an integer t, the trace of the Frobenius
     
    16501596{
    16511597   int pr=printlevel;
    1652    def R=basering;
    16531598   ring S=q,(y,x),(L(100000),lp);
    1654    number a=imap(R,a);
    1655    number b=imap(R,b);
     1599   number a=aa;
     1600   number b=bb;
    16561601   poly F=y2-x3-a*x-b;       // the curve C
    16571602   poly G=generateG(a,b,l);
     
    16931638         pause();
    16941639      }
    1695       setring R;
    16961640      return(t);
    16971641   }
     
    17351679   //=== test if all points of C[l] satisfy  (x,y)^(q^2)=-[ql](x,y)
    17361680   //=== if so: t mod l =0 is returned
    1737    if(size(reduce(J,I))==0){setring R;return(0);}
     1681   if(size(reduce(J,I))==0){return(0);}
    17381682
    17391683   //==== test for (x,y)^(q^2)=[ql](x,y) for some point
     
    17581702   if(deg(J[1])>0)
    17591703   {
    1760       setring R;
    17611704      int w=int(squareRoot(q,l));
    1762       setring S;
    17631705      //=== +/-2w mod l zurueckgeben, wenn (x,y)^q=+/-[w](x,y)
    17641706      //==== the case t>0 :  (Q1/P1,Q2/P2)=[w](x,y) ==============
     
    18501792         pause();
    18511793      }
    1852       if(size(reduce(J,I))==0){setring R;return(t);}
     1794      if(size(reduce(J,I))==0){return(t);}
    18531795      J=Q1*L1-P1*H1,Q2*L2+P2*H2;
    1854       if(size(reduce(J,I))==0){setring R;return(l-t);}
     1796      if(size(reduce(J,I))==0){return(l-t);}
    18551797   }
    18561798   ERROR("something is wrong in testElliptic");
     
    18581800example
    18591801{ "EXAMPLE:"; echo = 2;
    1860    ring R = 0,z,dp;
    18611802   testElliptic(1267985441,338474977,64740730,3);
    18621803}
     
    18681809//============= Lenstra's ECM Factorization ==================================
    18691810
    1870 proc factorLenstraECM(number N, list S, int B, list #)
     1811proc factorLenstraECM(bigint N, list S, int B, list #)
    18711812"USAGE:  factorLenstraECM(N,S,B); optional: factorLenstraECM(N,S,B,d);
    18721813         d+1 the number of loops in the algorithm (default d=0)
     
    18801821{
    18811822   list L,P;
    1882    number g,M,w;
     1823   bigint g,M,w;
    18831824   int i,j,k,d;
    18841825   int l=size(S);
     
    19151856example
    19161857{ "EXAMPLE:"; echo = 2;
    1917    ring R = 0,z,dp;
    19181858   list L=primList(1000);
    19191859   factorLenstraECM(181*32003,L,10,5);
    1920    number h=10;
     1860   bigint h=10;
    19211861   h=h^30+25;
    19221862   factorLenstraECM(h,L,4,3);
     
    19251865//================= ECPP (Goldwasser-Kilian) a primaly-test =============
    19261866
    1927 proc ECPP(number N)
     1867proc ECPP(bigint N)
    19281868"USAGE:  ECPP(N);
    19291869RETURN: message:N is not prime or {L,P,m,q} as certificate for N being prime@*
     
    19441884{
    19451885   list L,S,P;
    1946    number m,q;
     1886   bigint m,q;
    19471887   int i;
    19481888
    1949    number n=intRoot(intRoot(N));
     1889   bigint n=intRoot(intRoot(N));
    19501890   n=(n+1)^2;                         //lower bound for q
    19511891   while(1)
     
    19611901      if(n<q){break;}
    19621902   }
    1963    number u=m/q;
     1903   bigint u=m/q;
    19641904   while(1)
    19651905   {
     
    19761916example
    19771917{ "EXAMPLE:"; echo = 2;
    1978    ring R = 0,z,dp;
    1979    number N=1267985441;
     1918   bigint N=1267985441;
    19801919   ECPP(N);
    19811920}
     
    19851924   int i;
    19861925   intvec v;
    1987    number n;
    1988    number t=27;
     1926   bigint n;
     1927   bigint t=27;
    19891928   for(i=size(s);i>0;i--)
    19901929   {
     
    20241963}
    20251964
    2026 static proc numberToWord(number n)
     1965static proc numberToWord(bigint n)
    20271966{
    20281967   int i,j;
    20291968   string v;
    20301969   list s;
    2031    number t=27;
    2032    number mm;
    2033    number nn=n;
     1970   bigint t=27;
     1971   bigint mm;
     1972   bigint nn=n;
    20341973   while(nn>t)
    20351974   {
     
    20371976      mm=nn mod t;
    20381977      s[j]=mm;
    2039       nn=(nn-mm)/t;
     1978      nn=(nn-mm) div t;
    20401979   }
    20411980   j++;
     
    20772016"USAGE:  code(s); s a string
    20782017ASSUME:  s contains only small letters and space
    2079 COMPUTE: a number, RSA-coding of the string s
     2018COMPUTE: a bigint, RSA-coding of the string s
    20802019RETURN:  return RSA-coding of the string s as string
    20812020EXAMPLE: code;  shows an example
     
    20832022{
    20842023   ring r=0,x,dp;
    2085    number
     2024   bigint
    20862025p=398075086424064937397125500550386491199064362342526708406385189575946388957261768583317;
    2087    number
     2026   bigint
    20882027q=472772146107435302536223071973048224632914695302097116459852171130520711256363590397527;
    2089    number n=p*q;
    2090    number phi=(p-1)*(q-1);
    2091    number e=1234567891;
    2092    list L=exgcdN(e,phi);
    2093    number d=L[1];
    2094    number m=wordToNumber(s);
    2095    number c=powerN(m,e,n);
     2028   bigint n=p*q;
     2029   bigint phi=(p-1)*(q-1);
     2030   bigint e=1234567891;
     2031   //bigint d=extgcd(e,phi)[2];
     2032   bigint m=wordToNumber(s);
     2033   bigint c=powerN(m,e,n);
    20962034   string cc=string(c);
    20972035   return(cc);
     
    21052043proc decodeString(string g)
    21062044"USAGE:  decodeString(s); s a string
    2107 ASSUME:  s is a string of a number, the output of code
     2045ASSUME:  s is a string of a bigint, the output of code
    21082046COMPUTE: a string, RSA-decoding of the string s
    21092047RETURN:  return RSA-decoding of the string s as string
     
    21112049"
    21122050{
    2113    ring r=0,x,dp;
    2114    number
     2051   bigint
    21152052p=398075086424064937397125500550386491199064362342526708406385189575946388957261768583317;
    2116    number
     2053   bigint
    21172054q=472772146107435302536223071973048224632914695302097116459852171130520711256363590397527;
    2118    number n=p*q;
    2119    number phi=(p-1)*(q-1);
    2120    number e=1234567891;
    2121    list L=exgcdN(e,phi);
    2122    number d=L[1];
    2123    execute("number c="+g+";");
    2124    number f=powerN(c,d,n);
     2055   bigint n=p*q;
     2056   bigint phi=(p-1)*(q-1);
     2057   bigint e=1234567891;
     2058   bigint d=extgcd(e,phi)[2];
     2059   execute("bigint c="+g+";");
     2060   bigint f=powerN(c,d,n);
    21252061   string s=numberToWord(f);
    21262062   return(s);
  • Tst/Manual.lst

    r38a53c0 r2fede6  
    403403Manual/ERROR.tst
    404404Manual/exteriorBasis.tst
    405 Manual/gcdN.tst
    406405Manual/genericmat.tst
    407406Manual/GKdim.tst
     
    612611Manual/equidimMax.tst
    613612Manual/execute.tst
    614 Manual/exgcdN.tst
    615613Manual/extendring.tst
    616614Manual/farey.tst
  • Tst/Manual/Cornacchia.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 Cornacchia.res.gz
    2 M'XL("-`G<DX``T-O<FYA8V-H:6$N<F5S``L.<?'T4U!0,+13\/%T4E`J*2[1
     2M'XL("#3!F5,``T-O<FYA8V-H:6$N<F5S``L.<?'T4U!0,+13\/%T4E`J*2[1
    33MR\E,4K)6`++B,_,R2S0TK;E`M(*=G8)S?E%>8G)R1F:B7EYJN5YQ26()5S#4
    4 M!".H"8DEV9EYQ1!#X)+&=@I%F7GI"D$*M@H&.A4Z*04(.1-D<S5,374L34T-
    5 I@99&&\9:<8&<9L85;01E&L-UF=J!70AR0FFQ!E"]"A<`$;`Z*<P`````
     4M!".H"8DEV9EYQ1!#X)+&R'HU3$UU+$U-#8$&1QO&6G&!K#?CBC:",HWANDSL
     55P*X`65-:K`%4K\(%`"G@Y9>P````
    66`
    77end
  • Tst/Manual/Cornacchia.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "atkins.lib";
    3 ring R = 0,x,dp;
    43Cornacchia(55,9551);
    54tst_status(1);$
  • Tst/Manual/HilbertClassPoly.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 HilbertClassPoly.res.gz
    2 M'XL("/HG<DX``TAI;&)E<G1#;&%S<U!O;'DN<F5S`&6/P0J"0!1%]W[%0UHH
    3 MJ3@SCJ.(LR@7"1&![4-)8LBF<$:ROT]+=-'J/CAPWKW%*<L/`(`X[/,-F%II
    4 MKQ&5F<!PG844VK(38TS@'':BJ>I6;YM2J>.C>7NR?GE*E]HH)@^>/*6^":E^
    5 MJAD2#JV05V@A!=_IG<MS80$'V=T'.V2IB\D"Z/];*W.H/]3JR9H$,6+4[[%+
    6 G$44X#B-&^S7"C*$H\B,:$T9G5<B_J\;"G;*0G:R,#R\9V`,``0``
     2M'XL("!_&F5,``TAI;&)E<G1#;&%S<U!O;'DN<F5S`&6/30N"0!1%]_Z*A[10
     3M_,"9<1Q%G$6Y2(@(;!]*(D,RA3.1_?NT1!>M[H,#Y]U;GO/B"`"(PZ'8@JF5
     4M]CM1FRF,UT5(H2T[-:8$SF$ONKKI]:ZKE#K=N[<OFY>O=*6-<O;@V5/IFY#J
     5MIUH@X=`+V4(/&03NX%X?*PLYU*(54D.>>9BL@/Z_M7*7!F.M@3@D3!"CP8`]
     6HBBC"210S.C@(,X;B.(AI0AA=5!'_KIH*/Y6%['1C?`"B>$F/``$`````
    77`
    88end
  • Tst/Manual/HilbertClassPoly.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:242812
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:673888
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:765440
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:107
     11 >> tst_memory_0 :: 1402586655:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:307984
     21 >> tst_memory_1 :: 1402586655:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2247776
     31 >> tst_memory_2 :: 1402586655:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2339192
     41 >> tst_timer_1 :: 1402586655:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:25
  • Tst/Manual/HilbertClassPoly.tst

    r38a53c0 r2fede6  
    22LIB "atkins.lib";
    33ring r = 0,x,dp;
    4 number D=-23;
     4bigint D=-23;
    55HilbertClassPoly(D,50);
    66tst_status(1);$
  • Tst/Manual/MillerRabin.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 MillerRabin.res.gz
    2 M'XL("`8H<DX``TUI;&QE<E)A8FEN+G)E<P`+#G'Q]%-04#"T4_#Q=%)0*BDN
     2M'XL("!W)F5,``TUI;&QE<E)A8FEN+G)E<P`+#G'Q]%-04#"T4_#Q=%)0*BDN
    33MT<O)3%*R5@"RXC/S,DLT-*VY0+2"G9V";V9.3FI14&)29IY>7FJY7G%)8@E7
    4 M,-0((Z@1R465!27Y$%/@DL9V"D69>>D*00JV"@8Z53HI!0@Y$SN%O-+<I-0B
    5 MA0I;(X2PJ1V07Q%G;F&N:X@0-4-QA4:%CC'0?09P:7,[L,-!#BLMUC#4M%;A
    6 *`@!VZ5@6XP``````
     4M,-0((Z@1R465!27Y$%/@DL9V"DF9Z9EY)0H5MD8(81,[(+\BSMS"7-<0(6J*
     5C8I-&A8XQT`T&<&DS.[#C0):7%FL8:EJK<`$`*E]&ML<`````
    76`
    87end
  • Tst/Manual/MillerRabin.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:244380
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:8482816
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:9039872
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:32
     11 >> tst_memory_0 :: 1402587421:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:259432
     21 >> tst_memory_1 :: 1402587421:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:9879552
     31 >> tst_memory_2 :: 1402587421:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:9935744
     41 >> tst_timer_1 :: 1402587421:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:9
  • Tst/Manual/MillerRabin.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    4 number x=2;
     3bigint x=2;
    54x=x^787-1;
    65MillerRabin(x,3);
  • Tst/Manual/ShanksMestre.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 ShanksMestre.res.gz
    2 M'XL("$PH<DX``U-H86YK<TUE<W1R92YR97,`"PYQ\?134%`PM%/P\7124"HI
     2M'XL("`'%F5,``U-H86YK<TUE<W1R92YR97,`"PYQ\?134%`PM%/P\7124"HI
    33M+M'+R4Q2LE8`LN(S\S)+-#2MN4"T@IV=0G!&8EYVL6]J<4E1JEY>:KE><4EB
    4 M"5<PU`PCJ!G)194%)?D08^"2QG8*19EYZ0I!"K8*!CI5.BD%"#D35),UC(T,
    5 I#(QUS`UUS`R,@+8#N4:&<,6F=F"G@6PN+=8PU+16X0(`#2PBJL4`````
     4M"5<PU`PCJ!G)194%)?D08^"2QJBZ-8R-#`R,=<P-=<P,C(`V`+E&AG#%)G9@
     55ZT&FEQ9K&&I:JW`!``6MC)*I````
    66`
    77end
  • Tst/Manual/ShanksMestre.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:235496
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1171456
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1265852
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:31
     11 >> tst_memory_0 :: 1402586369:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:262640
     21 >> tst_memory_1 :: 1402586369:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2265088
     31 >> tst_memory_2 :: 1402586369:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2658440
     41 >> tst_timer_1 :: 1402586369:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:5
  • Tst/Manual/ShanksMestre.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    43ShanksMestre(32003,71,602);
    54tst_status(1);$
  • Tst/Manual/SolowayStrassen.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 SolowayStrassen.res.gz
    2 M'XL("$PH<DX``U-O;&]W87E3=')A<W-E;BYR97,`79!!"X)`$(7O_HI!.BC)
    3 MNNZ:%N(>HHL0'=K.A9:D8*NX*V*_/BW3Z#3#^V8>O,=/N^@```Z#?;0%74F%
    4 MBCS1`^BW2RYR99B!-DQ@#'A9E&W<<57'4J8"B;1%4L5*XZ,-&6VN=5>I\N,T
    5 M0<J@SL4=CA`"MI[6K9J9RT`TCR2M(0L=/.NK2:_"[.Q@O"2>/V./@6U_B4M]
    6 L0F?FHY&1GGF44/?G<8W^PQB91?NH>#K9L'<'0[Y&&HX9++07P>E/W"X!````
     2M'XL("*3$F5,``U-O;&]W87E3=')A<W-E;BYR97,`78]/"X)`$,7O?HHA.BC%
     3MNG],`W$/T46(+MNYT)!<D%7<"?';IV4:G69XOYG'>^IR3,\`P"2<T@.LT"*I
     4M=+Z*8=ANVFATO=@9)T@)JJ[J+NL5MIFUA2&FZ(C%#!TUV?#)YM[V#=8?IQD*
     5M";E^:(-0)HPN>C#K35)>&:4;'D8+WDGP_2\)1,3%PD(R,3ZP4'`1_#Q&Y#^P
     6<6V[%4(?.)WOY[CEV>%J7>?':>0$P9U4_$@$`````
    77`
    88end
  • Tst/Manual/SolowayStrassen.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:226920
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:699116
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:15
     11 >> tst_memory_0 :: 1402586276:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:255056
     21 >> tst_memory_1 :: 1402586276:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2240296
     31 >> tst_memory_2 :: 1402586276:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2281280
     41 >> tst_timer_1 :: 1402586276:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:1
  • Tst/Manual/SolowayStrassen.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    4 number h=10;
    5 number p=h^100+267;
     3bigint h=10;
     4bigint p=h^100+267;
    65//p=h^100+43723;
    76//p=h^200+632347;
  • Tst/Manual/all.lst

    r38a53c0 r2fede6  
    481481evaluate_reynolds.tst
    482482execute.tst
    483 exgcdN.tst
    484483exp2pt.tst
    485484expo.tst
  • Tst/Manual/babyGiant.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 babyGiant.res.gz
    2 M'XL("/(H<DX``V)A8GE':6%N="YR97,`38_1"H(P&(7O?8J#=*$PAK.L0-Q%
    3 M!"%$%]E]N)(8U!HZB?7T:<G6U7_X/CB<OSIMRP,`QK$O-PA-9^A=BC#'D,Y2
    4 M21/%>3!><`Y1"[N3M3)4-2_:F=H$U5203@67UFKS_'4X.>=HI;KAB`()>9.K
    5 M]F[!H?J':%J((O4X<]@6+/%\Z;@>./-B]3<O$L02/0Q/,^?7_/O2.+KO(A;G
    6 +L^`#+EU^7?T`````
     2M'XL("*_#F5,``V)A8GE':6%N="YR97,`"PYQ\?134%`PM%/P\7124"HI+M'+
     3MR4Q2LE8`LN(S\S)+-#2MN4"T@IV=0E)B4J5[9F)>B5Y>:KE><4EB"5<PU``C
     4MJ`')194%)?D0,^"2QD"MF>F9>24*2;9&"&$3N'"EK:$!0MP4+EX`%#=$2)@A
     5F.4$C2:=2IP#H."-3N+RY'=C9((>5%FL8:EJK<`$`>W:YV>$`````
    76`
    87end
  • Tst/Manual/babyGiant.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:227140
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:699116
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:14
     11 >> tst_memory_0 :: 1402586031:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:255168
     21 >> tst_memory_1 :: 1402586031:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2240296
     31 >> tst_memory_2 :: 1402586031:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2281280
     41 >> tst_timer_1 :: 1402586031:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:1
  • Tst/Manual/babyGiant.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    4 number b=2;
    5 number y=10;
    6 number p=101;
     3bigint b=2;
     4bigint y=10;
     5bigint p=101;
    76babyGiant(b,y,p);
    87tst_status(1);$
  • Tst/Manual/ellipticAdd.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 ellipticAdd.res.gz
    2 M'XL("%4I<DX``V5L;&EP=&EC061D+G)E<P!5D$^+PC`0Q>_Y%(/LH4(H)JVZ
    3 MNR4!Q8L@Q7\W*4MKRQ+H=DL;$?WTSJ@D>LKC-[R7F;?;+Y8I``@-J^4<!K:W
    4 M86V*00*H?DQC;#!,&+V@-51U;5IKCK.R#)OJ'/8VMVSWC)#/B&-W:>W_(\4-
    5 M(PV=:7YA"PI&_,K+UL]B#<WIKZ@Z2)40GH\=S]4+GCA<J(G'4PVUZ2VL^<;#
    6 M3PWK@\B4].B+D,Q4[)`8$8JRET\$]K$A8^21)(3&L4<1H7=C_-92D/*<%QQW
    7 FPA8Q[YO1I@QC[DHR=-^5<`%X-55/U9[Z0`R3#W8#)!"]8*4!````
     2M'XL("$W(F5,``V5L;&EP=&EC061D+G)E<P!5D%T+@C`4AN_W*P[2A8%(FV4?
     3MLD'131"2V%U(:$D,Q"1/1/^^'0MG5SL\XWUV]J;'[2X&`*Y@O]N`@RWZE2Z<
     4M",QTUK5&=QPQ.D$I**M*-Z@OZ^O5K\N7WV*.+/TIQ$]Q>;P;O'\M_66@H-`W
     5M72/$DG/+ISW/Y0#/>ES(T.)00:5;A(.76#A7<#CQ3`J+%H1$)J<6+0D%V>`1
     6M/E&04#"PB!,RP9E%@M!_,/AKPHV]W"L\LY-IROA6C)9B1M--@IET-_%>8'Y-
     72]5)]S];EXVC$/L8%Q+^)`0``
    88`
    99end
  • Tst/Manual/ellipticAdd.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:229032
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:667928
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:702308
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:13
     11 >> tst_memory_0 :: 1402587213:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:257192
     21 >> tst_memory_1 :: 1402587213:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2242032
     31 >> tst_memory_2 :: 1402587213:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2283016
     41 >> tst_timer_1 :: 1402587213:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:1
  • Tst/Manual/ellipticAdd.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    4 number N=11;
    5 number a=1;
    6 number b=6;
     3bigint N=11;
     4bigint a=1;
     5bigint b=6;
    76list P,Q;
    87P[1]=2;
  • Tst/Manual/ellipticAllPoints.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 ellipticAllPoints.res.gz
    2 M'XL("%8I<DX``V5L;&EP=&EC06QL4&]I;G1S+G)E<P!E3TT+@D`4O.^O>$@'
    3 M!1$W,RUQH>@B2$1V6R3ZD'BPJ+0O(G]]FJ*'3F^886;>9*==L@<`+B!-MF"0
    4 M)D?AU8B@16<LD4PK8MT%(:!0"FO"VT:I0X4E::<LWHZF"[%L")H/0;?GIZ:J
    5 MSQI%3\`3RP<<(0;7;NQ[/6D+`0HU01K_M9@\Y';`;>Z[UF3P!6AL"C-M.;X*
    6 M1W[9?B`')8^8Y/F:=0N#%9/S'KM,>@,[V@+QF]R->;6-5C1C7WN<XS0=`0``
     2M'XL("&W%F5,``V5L;&EP=&EC06QL4&]I;G1S+G)E<P!E3\$*@D`4O.]7/**#
     3M@HBKF=K20M%%D`CLMDB4>'BPJ+0OHKZ^-<4.G=XPP\R\*<^'_`@`7$*1[V%!
     4MAGR-MX4`BR[8(CFN8,,%*:'1&GO">J?UJ<.6C-\V3]_0E5@Y!8534'U_]=2-
     5M6;,82=!H"(KM7Y+#4^XEW.-QX/X,*PD&WXU36(YGZ<S'MD5-2B68XM6&#2N2
     6>C*EPQ`%3T<3.MK7\SAH>?MA&5RS9!_.D6"$!`0``
    77`
    88end
  • Tst/Manual/ellipticAllPoints.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:256216
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:672672
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:899120
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:67
     11 >> tst_memory_0 :: 1402586477:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:309760
     21 >> tst_memory_1 :: 1402586477:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2256896
     31 >> tst_memory_2 :: 1402586477:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2475672
     41 >> tst_timer_1 :: 1402586477:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:28
  • Tst/Manual/ellipticAllPoints.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    43list L=ellipticAllPoints(181,71,150);
    54size(L);
  • Tst/Manual/ellipticMult.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 ellipticMult.res.gz
    2 M'XL("%8I<DX``V5L;&EP=&EC375L="YR97,`59!!2\-`$(7O^RL>Q4,*2^@D
    3 MM6K#[D&\%#0$ZTV")&V0A36&9(+HKW>7UMUZFL<W\`WS]B\/NQ(`:3SN[K'@
    4 MB5-KVD4!E]Y,;SA9%L)/:(W.6C.P.3S-EM.^^THG;ECLSX[L[#B,WP-_GC1A
    5 MF6N,IG_',Q16\D<>A[A;:_3S1]N-*!51Y->!-^H";P)NU2;B&PUK)D85T:U&
    6 M]4JURB*Z\RBKU3H@6GF4UQ<GB/[_FI2RD:VL9.[*<,*M\'+A/'\I/R4*!E>&
    7 3;]`7-$\)+8LK\0L5`*39;`$`````
     2M'XL("+"]F5,``V5L;&EP=&EC375L="YR97,`59!-"X)`$(;O^RL&Z:`@TJK9
     3MA^P>HHM0(M@M)%0D%A:3'(G^?;MHKIWFY1EXAGGSZRE)`8!R."='L+!'3XK*
     4MBD&ENV@%VDY,]`3.H9%2="CJRR#1:YNWUV.)))\<_N2H7Y\.GZ-F7@8<*O$0
     5M+4+**#4\G'G)%G@SXXI%!D<<I.@1,H.V'+(;+9AOT$XCOV"A07N-@F)Q@J[_
     6L_[%3MW0K-W,#];`2'H@V$>7YI6!,=#:HTG1+NH2AMZD3K\@7N?SV%%`!````
    87`
    98end
  • Tst/Manual/ellipticMult.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:229700
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:684032
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:786432
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:8
     11 >> tst_memory_0 :: 1402584496:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:257736
     21 >> tst_memory_1 :: 1402584496:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2242032
     31 >> tst_memory_2 :: 1402584496:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2292968
     41 >> tst_timer_1 :: 1402584496:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2
  • Tst/Manual/ellipticMult.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    4 number N=11;
    5 number a=1;
    6 number b=6;
     3bigint N=11;
     4bigint a=1;
     5bigint b=6;
    76list P;
    87P[1]=2;
  • Tst/Manual/ellipticRandomPoint.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 ellipticRandomPoint.res.gz
    2 M'XL("%<I<DX``V5L;&EP=&EC4F%N9&]M4&]I;G0N<F5S``L.<?'T4U!0,+13
     2M'XL(",3!F5,``V5L;&EP=&EC4F%N9&]M4&]I;G0N<F5S``L.<?'T4U!0,+13
    33M\/%T4E`J*2[1R\E,4K)6`++B,_,R2S0TK;E`M(*=G4)J3DYF04EF<E!B7DI^
    4 M;D!^9EZ)7EYJN5YQ26()5S#4*".H4<E%E04E^1#3X)+&=@I%F7GI"D$*M@H&
    5 M.E4Z*04(.1.L%F@8&QD8&.L8ZQA:&`*=$FT8:\4%LL7(PM2<*]H(PC,T-S$W
    6 >XXHVAO+@1IK:@?T!<E]IL090OPH7`""6MF#R````
     4M;D!^9EZ)7EYJN5YQ26()5S#4*".H4<E%E04E^1#3X)+&6`W1,#8R,##6,=8Q
     5MM#`$6A=M&&O%!3+)R,+4G"O:",(S-#<Q-^.*-H;RX$::V('="G)#:;$&4+\*
     6*%P"?YU8+U@``````
    77`
    88end
  • Tst/Manual/ellipticRandomPoint.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:229072
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:895820
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:9
     11 >> tst_memory_0 :: 1402585540:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:257240
     21 >> tst_memory_1 :: 1402585540:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2240296
     31 >> tst_memory_2 :: 1402585540:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2469896
     41 >> tst_timer_1 :: 1402585540:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:3
  • Tst/Manual/ellipticRandomPoint.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    43ellipticRandomPoint(32003,3,181);
    54tst_status(1);$
  • Tst/Manual/euler.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 euler.res.gz
    2 M'XL("&`I<DX``V5U;&5R+G)E<P`+#G'Q]%-04#"T4_#Q=%)0*BDNT<O)3%*R
     2M'XL("-?%F5,``V5U;&5R+G)E<P`+#G'Q]%-04#"T4_#Q=%)0*BDNT<O)3%*R
    33M5@"RXC/S,DLT-*VY0+2"G9U":FE.:I%>7FJY7G%)8@E7,%2S$51S8G9Q8G8B
    4 M1#]<TMA.H2@S+UTA2,%6P4"G0B>E`"%G`C52PQ((#($6@6@#N+2I'=@5(+M*
    5 /BS6`\BI<`*-_1^FP````
     4H1#]<TABJ3<,2"`R!AH%H`[BTB1W8)I!YI<4:0'D5+@`BI^XCE```````
    65`
    76end
  • Tst/Manual/euler.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:232844
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:667972
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:833532
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:97
     11 >> tst_memory_0 :: 1402586583:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:262224
     21 >> tst_memory_1 :: 1402586583:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2248704
     31 >> tst_memory_2 :: 1402586583:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2408992
     41 >> tst_timer_1 :: 1402586583:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:37
  • Tst/Manual/euler.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "aksaka.lib";
    3 ring R = 0,x,dp;
    43euler(99991);
    54tst_status(1);$
  • Tst/Manual/factorLenstraECM.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 factorLenstraECM.res.gz
    2 M'XL("'<I<DX``V9A8W1O<DQE;G-T<F%%0TTN<F5S`&V006_",`R%[_T5%MJA
    3 M95'E-'2`JN;`M@-2X`"<0845&@E"E1A-VZ\G!=0>X&3K^?E[LI>KK^D<`+@$
    4 M-9U`CQS%1[WM9>"[C3::PB@+F@I2PK[8T=FJTCBRQ??G+#;E;^RHH&#YX"0/
    5 MSL[^U72^H]JAD&"U.<`"<D#VSW[J;C:0<-2.0.6UU2?EVY`C8M0YTN?\D(]X
    6 M7R2(@BG&D:7>[J5VY4."N9RVI84JY]BAAM(+U5K@>Y)VZNA%0.7!`R8:KFB-
    7 58WG[3G/XQ84\RMZ"*Z)3<[](`0``
     2M'XL("#O%F5,``V9A8W1O<DQE;G-T<F%%0TTN<F5S`&V03PN"0!#%[WZ*03IH
     3MB>RZ6H*XA_X<A*U+G0L5RP53<2>B;]]:HH<ZS?#FS>\Q<SQMDP,`4`XB68.)
     4M"MU*9F8$NKO(6J)E1T9?@7.XICDVG2AJA5VZV^S=NGBZ"E,TC@/'&SAY]VJQ
     5M^:+&(>-0284@XK:3=Z%;BQ)"[,GA_V98-*1SYA'"'.%0X@3:KJ5Q)>"0R9NL
     6M$<J8D@FUY%HHSXPLO&!25W\"2@WV'=9SV6@,^><#_7$/95$[FAEO><@(BRP!
     7"````
    88`
    99end
  • Tst/Manual/factorLenstraECM.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:238616
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:913408
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1798144
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:56
     11 >> tst_memory_0 :: 1402586427:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:268232
     21 >> tst_memory_1 :: 1402586427:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2318336
     31 >> tst_memory_2 :: 1402586427:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2367488
     41 >> tst_timer_1 :: 1402586427:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:16
  • Tst/Manual/factorLenstraECM.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    43list L=primList(1000);
    54factorLenstraECM(181*32003,L,10,5);
    6 number h=10;
     5bigint h=10;
    76h=h^30+25;
    87factorLenstraECM(h,L,4,3);
  • Tst/Manual/pFactor.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 pFactor.res.gz
    2 M'XL("!Y?<DX``W!&86-T;W(N<F5S`$5/RPJ"0!3=^Q47::$TR#PT"W$6$8$@
    3 M+;)UH28YX(MQ).KK4Q-G=0_G=3G)[11=`(!PB*,CF*I73B4R,X`1/40CE&4'
    4 MQG2!<^C.::Y:Z33%V^E5JHQDB=,EGLM/I]I_PRHR#E(T+[A""!A]T;/3FLNA
    5 M$KV"..RDJ.,16@1C;&N'M[ZU"'4)<1DB#,6CPW/]U;7CT`QU5D@H0X)UVN<C
    6 F4=X9WE)/LWO=62**YS9&O54_\'G^-''H+6('&^,'Q_M>(2D!````
     2M'XL(",^^F5,``W!&86-T;W(N<F5S`$6/RPJ"0!2&]S[%(5J,)#(7S4"<140@
     3M#&UL7:A$#IB*<R)Z^T:3<75^_LL'I[B>\@L`,`DJ/\(&#8:MKC8I6'77G4;B
     4MI]YT04H8SF6-_1AVCT]HL$2O6.9\F=?C=\#^3W"AD-!J@Z"R8=0O925AE%)_
     5M;40.31B/&(M$P$2@;"..$M>*)53ZJ3N$)F-T7>^E-9J;H#L>KVZR,IN`TYDF
     68>.SR@YQ?G-YX&\+\=.O]`(DL1Z8-`0``
    77`
    88end
  • Tst/Manual/pFactor.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,z,dp;
    43list L=primList(1000);
    54pFactor(1241143,13,L);
    6 number h=10;
     5bigint h=10;
    76h=h^30+25;
    87pFactor(h,20,L);
  • Tst/Manual/rho.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 rho.res.gz
    2 M'XL("(9?<DX``W)H;RYR97,`18]!"X(P&(;O_HH7Z:`PQ%E6(.X0783HD-VC
    3 ME=2@YM!)[=\W3;;3/IZ'!][5YWUU!$`9#M4.H>YU\A(\+&"OBY!"1W$1C"\8
    4 M0_=L$]E\DEY?=5#/:3:GM\XHW?YK)Y<V$O*!$TJDY$ONRKL5@QS>O.G`R\SC
    5 LW&%3TM3SM>/*<NK%9AH6<6*(LF.SW)DMF[XQSAWZB,;%(O@!/SV2F?$`````
     2M'XL("&J^F5,``W)H;RYR97,`"PYQ\?134%`PM%/P\7124"HI+M'+R4Q2LE8`
     3MLN(S\S)+-#2MN4"T@IV=0E%&OEY>:KE><4EB"5<P5*L15&MR465!23Y$-US2
     4MV$XA*3,],Z]$(<G6""%L`A>NM#4T0(B;PL4+@.*&"`DSL.4:23J5.@5`!QF9
     5:PF7,[<!.!3FIM%C#4--:A0L`:?W-R]4`````
    66`
    77end
  • Tst/Manual/rho.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:228308
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:667592
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:767200
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:11
     11 >> tst_memory_0 :: 1402584682:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:256336
     21 >> tst_memory_1 :: 1402584682:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2241648
     31 >> tst_memory_2 :: 1402584682:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2341400
     41 >> tst_timer_1 :: 1402584682:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2
  • Tst/Manual/rho.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,x,dp;
    4 number b=2;
    5 number y=10;
    6 number p=101;
     3bigint b=2;
     4bigint y=10;
     5bigint p=101;
    76rho(b,y,p);
    87tst_status(1);$
  • Tst/Manual/s.lst

    r38a53c0 r2fede6  
    412412ERROR.tst
    413413exteriorBasis.tst
    414 gcdN.tst
    415414genericmat.tst
    416415getdump.tst
     
    623622equidimMax.tst
    624623execute.tst
    625 exgcdN.tst
    626624extendring.tst
    627625farey.tst
  • Tst/Manual/solutionsMod2.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 solutionsMod2.res.gz
    2 M'XL(",Z)<TX``W-O;'5T:6]N<TUO9#(N<F5S`%V.30N"0!"&[_Z*03HH#.+Z
    3 MU4'<0W01LD-VBPC+B`7;%7<D^_>M)0K!##/POCP\Y7&;[P&`<=CE&[!)D]>(
    4 MJYV"^2Y""G+<U!HO<`Y:-3T))76AZL"3]Y>GJ2*KG"#!!+EU[Y;4CS.'(8=.
    5 MR`<<(`,?!ZS;)8LX/"OJQ`#%*3R;R1@&&&*$,2:X-ALOY?C/PRF,(4,?V5Q)
    6 4^%=_E.NUP]QT97T`LC/QR^D`````
     2M'XL(""J^F5,``W-O;'5T:6]N<TUO9#(N<F5S``L.<?'T4U!0,+13\/%T4E`J
     3M*2[1R\E,4K)6`++B,_,R2S0TK;E`M(*=G4)Q?DYI269^7K%O?HJ17EYJN5YQ
     4M26()5S#4$".H(<E%E04E^1!SX)+&=@I)F>F9>26YB24*OM'&L4!D:ZACI&.L
     5M8Z)CJF.F8P[$I@CU)FC6:?@"'6*H8Z!C"%=B:@=V)<@-I<4:AIK6*EP`9$][
     6%#-``````
    77`
    88end
  • Tst/Manual/solutionsMod2.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:227024
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:699116
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:8
     11 >> tst_memory_0 :: 1402584618:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:255024
     21 >> tst_memory_1 :: 1402584618:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2240296
     31 >> tst_memory_2 :: 1402584618:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2281280
     41 >> tst_timer_1 :: 1402584618:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2
  • Tst/Manual/solutionsMod2.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,x,dp;
    4 matrix M[3][3]=1,2,3,4,5,6,7,6,5;
     3bigintmat M[3][3]=1,2,3,4,5,6,7,6,5;
    54solutionsMod2(M);
    65tst_status(1);$
  • Tst/Manual/squareRoot.res.gz.uu

    r38a53c0 r2fede6  
    11begin 640 squareRoot.res.gz
    2 M'XL(".B)<TX``W-Q=6%R95)O;W0N<F5S``L.<?'T4U!0,+13\/%T4E`J*2[1
     2M'XL("/.]F5,``W-Q=6%R95)O;W0N<F5S``L.<?'T4U!0,+13\/%T4E`J*2[1
    33MR\E,4K)6`++B,_,R2S0TK;E`M(*=G4)Q86EB46I0?GZ)7EYJN5YQ26()5S#4
    4 M!".H"<E%E04E^1!#X)+&=@I%F7GI"D$*M@H&.A4Z*04(.1-D<S4LC`U-+2P-
    5 M3(P,+8TMS`PL=(R-#`R,@6XPM#"W,(%K,K4#.Q#D@M)B#4--:Q4N`%OEAN'+
    6 #````
     4M!".H"<E%E04E^1!#X)+&R'HU+(P-32TL#4R,#"V-+<P,+'2,C0P,C('V&%J8
     5<6YC`-9G8@1T!LJ6T6,-0TUJ%"P"S[V7*KP``````
    76`
    87end
  • Tst/Manual/squareRoot.stat

    r38a53c0 r2fede6  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:228480
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:666332
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:813860
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:8
     11 >> tst_memory_0 :: 1402584563:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:256512
     21 >> tst_memory_1 :: 1402584563:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2240296
     31 >> tst_memory_2 :: 1402584563:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2387896
     41 >> tst_timer_1 :: 1402584563:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2
  • Tst/Manual/squareRoot.tst

    r38a53c0 r2fede6  
    11LIB "tst.lib"; tst_init();
    22LIB "crypto.lib";
    3 ring R = 0,x,dp;
    43squareRoot(8315890421938608,32003);
    54tst_status(1);$
  • Tst/regress.lst

    r38a53c0 r2fede6  
    631631Manual/equidimMax.tst
    632632Manual/execute.tst
    633 Manual/exgcdN.tst
    634633Manual/extendring.tst
    635634Manual/farey.tst
Note: See TracChangeset for help on using the changeset viewer.