Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Merge branch 'master' of git://maxima.git.sourceforge.net/gitroot/max…

…ima/maxima into quicklisp
  • Loading branch information...
commit 0b7086d5bea1642678fc56dadede92fe530fd1ae 2 parents ef8788f + 2f2fac9
@filonenko-mikhail authored
View
65 doc/info/Number.texi
@@ -124,6 +124,36 @@ returning. @code{burn} invokes the approximation for even integers @var{n} >
@end deffn
@c -----------------------------------------------------------------------------
+@anchor{chinese}
+@deffn {Function} chinese ([@var{r_1}, @dots{}, @var{r_n}], [@var{m_1}, @dots{}, @var{m_n}])
+
+Solves the system of congruences @code{x = r_1 mod m_1}, @dots{}, @code{x = r_n mod m_n}.
+The remainders @var{r_n} may be arbitrary integers while the moduli @var{m_n} have to be
+positive and pairwise coprime integers.
+
+@example
+(%i1) mods : [1000, 1001, 1003, 1007];
+(%o1) [1000, 1001, 1003, 1007]
+(%i2) lreduce('gcd, mods);
+(%o2) 1
+(%i3) x : random(apply("*", mods));
+(%o3) 685124877004
+(%i4) rems : map(lambda([z], mod(x, z)), mods);
+(%o4) [4, 568, 54, 624]
+(%i5) chinese(rems, mods);
+(%o5) 685124877004
+(%i6) chinese([1, 2], [3, n]);
+(%o6) chinese([1, 2], [3, n])
+(%i7) %, n = 4;
+(%o7) 10
+@end example
+
+@opencatbox
+@category{Number theory}
+@closecatbox
+@end deffn
+
+@c -----------------------------------------------------------------------------
@anchor{cf}
@deffn {Function} cf (@var{expr})
@@ -339,6 +369,23 @@ For the Euler-Mascheroni constant, see @code{%gamma}.
@end deffn
@c -----------------------------------------------------------------------------
+@anchor{factors_only}
+@defvr {Option variable} factors_only
+Standardwert: @code{false}
+
+Controls the value returned by @mrefdot{ifactors}. The default @code{false}
+causes @code{ifactors} to provide information about multiplicities of the
+computed prime factors. If @code{factors_only} is set to @code{true},
+@code{ifactors} returns nothing more than a list of prime factors.
+
+Example: See @mrefdot{ifactors}.
+
+@opencatbox
+@category{Number theory}
+@closecatbox
+@end defvr
+
+@c -----------------------------------------------------------------------------
@anchor{fib}
@deffn {Function} fib (@var{n})
@@ -411,13 +458,21 @@ For a positive integer @var{n} returns the factorization of @var{n}. If
factors, ifactors returns @code{[[p1, e1], ... , [pk, ek]]}.
Factorization methods used are trial divisions by primes up to 9973,
-Pollard's rho method and elliptic curve method.
+Pollard's rho and p-1 method and elliptic curves.
+
+The return value is controlled by the option variable @mrefdot{factors_only}.
+The default @code{false} causes @code{ifactors} to provide information about
+the multiplicities of the computed prime factors. If @code{factors_only}
+is set to @code{true}, @code{ifactors} returns nothing more than a list of
+prime factors.
@example
(%i1) ifactors(51575319651600);
(%o1) [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
(%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
(%o2) 51575319651600
+(%i3) ifactors(51575319651600), factors_only : true;
+(%o3) [2, 3, 5, 1583, 9050207]
@end example
@opencatbox
@@ -666,9 +721,9 @@ Miller-Rabin's test is used. If @code{primep (@var{n})} returns
@code{true}, then @var{n} is a prime number.
For @var{n} bigger than 341550071728321 @code{primep} uses
-@code{primep_number_of_tests} Miller-Rabin's pseudo-primality tests and
-one Lucas pseudo-primality test. The probability that @var{n} will pass
-one Miller-Rabin test is less than 1/4. Using the default value 25 for
+@code{primep_number_of_tests} Miller-Rabin's pseudo-primality tests and one
+Lucas pseudo-primality test. The probability that a non-prime @var{n} will
+pass one Miller-Rabin test is less than 1/4. Using the default value 25 for
@code{primep_number_of_tests}, the probability of @var{n} beeing
composite is much smaller that 10^-15.
@@ -685,7 +740,7 @@ Default value: 25
Number of Miller-Rabin's tests used in @code{primep}.
@opencatbox
-@category{Predicate functions} @category{Number theory}
+@category{Number theory}
@closecatbox
@end defvr
View
277 doc/info/de/Number.de.texi
@@ -6,6 +6,7 @@
@c Translation : Dr. Dieter Kaiser
@c Date : 06.01.2011
@c Revision : 26.02.2011
+@c Revision : 27.03.2012
@c
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------
@@ -165,6 +166,32 @@ Zahlen die kleiner oder gleich 255 die Funktion @code{bern} auf.
Das Kommando @code{load(bffac)} l@"adt die Funktion. Siehe auch @mrefdot{bern}
@end deffn
+@c --- 27.03.2012 VN -----------------------------------------------------------
+@anchor{chinese}
+@deffn {Funktion} chinese ([@var{r_1}, @dots{}, @var{r_n}], [@var{m_1}, @dots{}, @var{m_n}])
+
+L@"ost die simultanen Kongruenzen @code{x = r_1 mod m_1}, @dots{}, @code{x = r_n mod m_n}.
+Die Reste @var{r_n} und die Moduli @var{m_n} m@"ussen ganze Zahlen sein,
+die Moduli zus@"atzlich positiv und paarweise teilerfremd.
+
+@example
+(%i1) mods : [1000, 1001, 1003, 1007];
+(%o1) [1000, 1001, 1003, 1007]
+(%i2) lreduce('gcd, mods);
+(%o2) 1
+(%i3) x : random(apply("*", mods));
+(%o3) 685124877004
+(%i4) rems : map(lambda([z], mod(x, z)), mods);
+(%o4) [4, 568, 54, 624]
+(%i5) chinese(rems, mods);
+(%o5) 685124877004
+(%i6) chinese([1, 2], [3, n]);
+(%o6) chinese([1, 2], [3, n])
+(%i7) %, n = 4;
+(%o7) 10
+@end example
+@end deffn
+
@c --- 23.11.2010 DK -----------------------------------------------------------
@anchor{divsum}
@deffn {Funktion} divsum (@var{n}, @var{k})
@@ -285,30 +312,29 @@ Beispiele:
@end example
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{ifactors}
-@deffn {Function} ifactors (@var{n})
+@deffn {Funktion} ifactors (@var{n})
-@c For a positive integer @var{n} returns the factorization of @var{n}. If
-@c @code{n=p1^e1..pk^nk} is the decomposition of @var{n} into prime
-@c factors, ifactors returns @code{[[p1, e1], ... , [pk, ek]]}.
-
-Faktorisiert eine positive ganze Zahl @var{n}. Sind @code{n = p1^e1..pk^nk} die
+Faktorisiert eine positive ganze Zahl @var{n}. Sind @code{n = p1^e1 * ... * pk^nk} die
Faktoren der ganzen Zahl @var{n}, dann gibt @code{ifactor} das Ergebnis
-@code{[[p1, e1], ... , [pk, ek]]} zur@"uck.
+@code{[[p1, e1], ..., [pk, ek]]} zur@"uck.
-@c Factorization methods used are trial divisions by primes up to 9973,
-@c Pollard's rho method and elliptic curve method.
+F@"ur die Faktorisierung kommen Probedivision mit Primzahlen bis 9973,
+Pollards Rho- und p-1-Methode oder Elliptischen Kurven zum Einsatz.
-F@"ur die Faktorisierung kommen eine einfache Primfaktorzerlegung mit Primzahlen
-bis zu 9973, das Z@"ahlk@"orpersieb nach Pollard oder die Methode der
-Elliptischen Kurven zum Einsatz.
+Die R@"uckgabe von ifactors wird von der Optionsvariablen @mrefdot{factors_only}
+beeinflusst.
+Werden lediglich die Primfaktoren ohne ihre Multiplizit@"at ben@"otigt,
+gen@"ugt es hierf@"ur, @code{factors_only : true} zu setzen.
@example
(%i1) ifactors(51575319651600);
(%o1) [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
(%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
(%o2) 51575319651600
+(%i3) ifactors(51575319651600), factors_only : true;
+(%o3) [2, 3, 5, 1583, 9050207]
@end example
@end deffn
@@ -354,18 +380,15 @@ Gibt die ganzzahlige @var{n}-te Wurzel des Betrags von @var{x} zur@"uck.
@end example
@end deffn
-@c --- 22.12.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{inv_mod}
-@deffn {Funktion} inv_mod (@var{n}, @var{p})
-
-@c Computes the inverse of @var{n} modulo @var{m}. @code{inv_mod (n,m)} returns
-@c @code{false}, if @var{n} is a zero divisor modulo @var{m}.
+@deffn {Funktion} inv_mod (@var{n}, @var{m})
-Berechnet das modulare Inverse von @var{n} zum Modul @var{p}. Das Argument
-@var{n} muss eine ganze Zahl und das Modul @var{p} eine positive ganze Zahl
-sein. @code{inv_mod(n,p)} gibt @code{false} zur@"uck, wenn das modulare Inverse
-nicht existiert. Das modulare Inverse existiert immer, wenn das Modul @var{p}
-eine Primzahl ist.
+Berechnet das modulare Inverse von @var{n} zum Modul @var{m}. Das Argument
+@var{n} muss eine ganze Zahl und der Modul @var{p} eine positive ganze Zahl
+sein. @code{inv_mod(n, m)} gibt @code{false} zur@"uck, wenn das modulare Inverse
+nicht existiert. Das modulare Inverse existiert, wenn @var{n} teilerfremd zum
+Modul @var{m} ist.
Siehe auch die Funktionen @mref{power_mod} und @mrefdot{mod}
@@ -374,7 +397,7 @@ Beispiele:
@example
(%i1) inv_mod(3, 41);
(%o1) 14
-(%i2) ratsimp(3^-1), modulus=41;
+(%i2) ratsimp(3^-1), modulus = 41;
(%o2) 14
(%i3) inv_mod(3, 42);
(%o3) false
@@ -407,14 +430,14 @@ Berechnet das Jacobi-Symbol f@"ur die Argumente @var{p} und @var{q}.
@end example
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{lcm}
@deffn {Funktion} lcm (@var{expr_1}, @dots{}, @var{expr_n})
@c Returns the least common multiple of its arguments. The arguments may be
@c general expressions as well as integers.
-Gibt den kleinsten gemeinsamen Teiler der Argumente zur@"uck. Die Argumente
+Gibt das kleinste gemeinsame Vielfache der Argumente zur@"uck. Die Argumente
k@"onnen ganze Zahlen und allgemeine Ausdr@"ucke sein.
@c @code{load ("functs")} loads this function.
@@ -422,7 +445,7 @@ k@"onnen ganze Zahlen und allgemeine Ausdr@"ucke sein.
Mit dem Kommando @code{load(functs)} wird die Funktion geladen.
@end deffn
-@c --- 22.12.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{mod}
@deffn {Funktion} mod (@var{x}, @var{p})
@@ -434,13 +457,13 @@ Mit dem Kommando @code{load(functs)} wird die Funktion geladen.
@c @code{mod (@var{x}, 1)} is a sawtooth function with period 1 with
@c @code{mod (1, 1) = 0} and @code{mod (0, 1) = 0}.
-Berechnet den Modulus @code{x mod p} des Arguments @var{x} zum Modul @var{p}.
-@var{x} und @var{p} k@"onnen ganze Zahlen, rationale Zahlen, Gleitkommazahlen
+Berechnet den Divisionsrest @code{x mod y} des Arguments @var{x} zum Modul @var{y}.
+@var{x} und @var{y} k@"onnen ganze Zahlen, rationale Zahlen, Gleitkommazahlen
oder allgemeine Ausdr@"ucke sein.
-Sind @var{x} und @var{p} reelle Zahlen und ist @var{p} ungleich Null, gibt
-@code{mod(@var{x}, @var{p})} das Ergebnis von @code{@var{x} - @var{p} *
-floor(@var{x} / @var{p})} zur@"uck. Weiterhin gilt f@"ur alle reellen Zahlen
+Sind @var{x} und @var{y} reelle Zahlen und ist @var{y} ungleich Null, gibt
+@code{mod(@var{x}, @var{y})} das Ergebnis von @code{@var{x} - @var{y} *
+floor(@var{x} / @var{y})} zur@"uck. Weiterhin gilt f@"ur alle reellen Zahlen
@code{mod(@var{x}, 0) = @var{x}}. F@"ur eine Diskussion dieser Definition siehe
Kapitel 3.4, "Concrete Mathematics" von Graham, Knuth, and Patashnik. Die
Funktion @code{mod(@var{x}, 1)} ist eine S@"agezahnfunktion mit der Periode 1
@@ -459,15 +482,15 @@ die komplexe Zahl ist.
@c @code{floor} and @code{ceiling} uses. Again, it's possible, although
@c unlikely, that @code{mod} could return an erroneous value in such cases.
-Wie f@"ur die Funktionen @code{floor} oder @code{ceiling} werden konstante
-Ausdr@"ucke, wie zum Beispiel @code{10 * %pi}, in gro@ss{}e Gleitkommazahlen
-umgewandelt, um @code{mod} zu berechnen. Diese Umwandlung kann zu Fehlern
-f@"uhren.
+Sind @var{x} und @var{y} konstante Ausdr@"ucke, wie zum Beispiel @code{10 * %pi},
+verwendet @code{mod} dasselbe @mrefdot{bfloat}-Auswertungsschema wie @code{floor}
+und @code{ceiling}. Diese Umwandlung kann, wenn auch unwahrscheinlich,
+zu Fehlern f@"uhren.
@c For nonnumerical arguments @var{x} or @var{y}, @code{mod} knows several
@c simplification rules:
-F@"ur nicht nummerische Argumente @var{x} oder @var{y} kennt @code{mod}
+F@"ur nicht numerische Argumente @var{x} oder @var{y} kennt @code{mod}
verschiedene Vereinfachungen.
Siehe auch die Funktionen @mref{power_mod} und @mrefdot{inv_mod}
@@ -475,22 +498,22 @@ Siehe auch die Funktionen @mref{power_mod} und @mrefdot{inv_mod}
Beispiele:
Zeige f@"ur zwei gro@ss{}e ganze Zahlen, dass f@"ur das modulare Rechnen die
-Regel @code{mod(a+b,p) = mod(a,p)+mod(b,p)} gilt.
+Regel @code{mod(a+b, m) = mod(mod(a, m) + mod(b, m), m)} gilt.
@example
-(%i1) a:random(10^20)+10^19;
+(%i1) a : random(10^20) + 10^19;
(%o1) 72588919020045581148
-(%i2) b:random(10^20)+10^19;
+(%i2) b : random(10^20) + 10^19;
(%o2) 35463666253140008825
-(%i3) p:random(10^20)+10^19;
+(%i3) m : random(10^20) + 10^19;
(%o3) 39127433614020247557
-(%i4) mod(a+b,p);
+(%i4) mod(a+b, m);
(%o4) 29797718045145094859
-(%i5) mod(mod(a,p)+mod(b,p),p);
+(%i5) mod(mod(a, m) + mod(b, m), m);
(%o5) 29797718045145094859
@end example
-Vereinfachung f@"ur nicht nummerische Argumente.
+Vereinfachung f@"ur nicht numerische Argumente.
@example
(%i1) mod (x, 0);
@@ -516,52 +539,77 @@ Gibt die kleinste Primzahl zur@"uck, die der Zahl @var{n} folgt.
@end example
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
+@anchor{power_mod}
+@deffn {Funktion} power_mod (@var{a}, @var{n}, @var{m})
+
+Verwendet einen modularen Algorithmus, um @code{a^n mod m} zu berechnen.
+Die Argumente @var{a} und @var{n} m@"ussen ganze Zahlen und der Modul @var{m}
+eine positive ganze Zahl sein. Ist @var{n} negativ, wird @mref{inv_mod}
+zur Berechnung des modularen Inversen aufgerufen.
+
+@code{power_mod (@var{a}, @var{n}, @var{m})} ist @"aquivalent zu
+@code{mod(a^n, m)}. Der Algorithmus von @code{power_mod} ist jedoch
+insbesondere f@"ur gro@ss{}e ganze Zahlen wesentlich effizienter.
+
+Siehe auch die Funktionen @mref{inv_mod} und @mrefdot{mod}
+
+Beispiele:
+
+@code{power_mod(a, n, m)} ist @"aquivalent zu @code{mod(a^n, m}. Das modulare
+Inverse wird mit der Funktion @code{inv_mod} berechnet.
+
+@example
+(%i1) power_mod(3, 15, 5);
+(%o1) 2
+(%i2) mod(3^15, 5);
+(%o2) 2
+(%i3) power_mod(2, -1, 5);
+(%o3) 3
+(%i4) inv_mod(2, 5);
+(%o4) 3
+@end example
+
+F@"ur gro@ss{}e ganze Zahlen ist @code{power_mod} effizienter. Der folgende
+Wert kann in keiner vern@"unftigen Zeit mit @code{mod(a^n, m)} berechnet
+werden.
+
+@example
+(%i1) power_mod(123456789, 123456789, 987654321);
+(%o1) 598987215
+@end example
+@end deffn
+
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{primep}
@deffn {Funktion} primep (@var{n})
-@c Primality test. If @code{primep (@var{n})} returns @code{false}, @var{n} is a
-@c composite number and if it returns @code{true}, @var{n} is a prime number
-@c with very high probability.
-
-F@"uhrt einen Test auf eine Primzahl f@"ur das Argument @var{n} durch. Hat
+F@"uhrt einen Primzahltest f@"ur das Argument @var{n} durch. Liefert
@code{primep} das Ergebnis @code{false}, ist @var{n} keine Primzahl. Ist das
-Ergebnis @code{true}, ist @var{n} mit gro@ss{}er Wahrscheinlichkeit eine
+Ergebnis @code{true}, ist @var{n} mit sehr gro@ss{}er Wahrscheinlichkeit eine
Primzahl.
-@c For @var{n} less than 10^16 a deterministic version of Miller-Rabin's
-@c test is used. If @code{primep (@var{n})} returns @code{true}, then @var{n}
-@c is a prime number.
-
-F@"ur ganze Zahlen @var{n} die kleiner als 10^16 sind wird eine probalistisches
-Miller-Rabin-Verfahren. Hat in diesem Fall @code{primep} das Ergebnis
-@code{true}, dann ist @var{n} eine Primzahl.
-
-@c For @var{n} bigger than 10^16 @code{primep} uses
-@c @code{primep_number_of_tests} Miller-Rabin's pseudo-primality tests and one
-@c Lucas pseudo-primality test. The probability that @var{n} will pass one
-@c Miller-Rabin test is less than 1/4. Using the default value 25 for
-@c @code{primep_number_of_tests}, the probability of @var{n} beeing composite is
-@c much smaller that 10^-15.
-
-F@"ur ganze Zahlen @var{n} gr@"o@ss{}er als 10^16 nutzt @code{primep} den
-Pseudo-Primzahlentest nach Miller-Rabin mit @mref{primep_number_of_tests} Tests
-und den Pseudo_Primzahlentest nach Lucas. Die Wahrscheinlichkeit, dass eine
-Zahl @var{n} den Pseudo-Primzahlentest nach Miller-Rabin passiert, ist kleiner
-als 1/4. Mit dem Standardwert 25 f@"ur die Optionsvariable
-@code{primpe_number_of_tests} ist die Wahrscheinlichkeit viel kleiner als
-10^-15.
+F@"ur ganze Zahlen @var{n} kleiner als 341550071728321 wird eine deterministische
+Variante des Miller-Rabin-Tests angewandt. Hat in diesem Fall @code{primep} den Wert
+@code{true}, dann ist @var{n} mit Sicherheit eine Primzahl.
+
+F@"ur ganze Zahlen @var{n} gr@"o@ss{}er 341550071728321 f@"uhrt @code{primep}
+@mref{primep_number_of_tests} Pseudo-Primzahl-Tests nach Miller-Rabin und
+einen Pseudo-Primzahl-Test nach Lucas durch. Die Wahrscheinlichkeit, dass
+eine zusammen gesetzte Zahl @var{n} einen Miller-Rabin-Test besteht, ist kleiner
+als 1/4. Mit dem Standardwert 25 @code{primpe_number_of_tests} sinkt diese
+Wahrscheinlichkeit damit unter einen Wert von 10^-15.
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{primep_number_of_tests}
@defvr {Optionsvariable} primep_number_of_tests
Standardwert: 25
@c Number of Miller-Rabin's tests used in @code{primep}.
-Die Anzal der Pseudo-Primzahlentests nach Miller-Rabin der Funktion
-@mrefdot{primep}
+Die Anzahl der Pseudo-Primzahl-Tests nach Miller-Rabin in der Funktion
+@mrefdot{primep}.
@end defvr
@c --- 27.11.2010 DK -----------------------------------------------------------
@@ -578,51 +626,6 @@ Gibt die gr@"o@ss{}te Primzahl zur@"uck, die kleiner als die Zahl @var{n} ist.
@end example
@end deffn
-@c --- 22.12.2010 DK -----------------------------------------------------------
-@anchor{power_mod}
-@deffn {Funktion} power_mod (@var{a}, @var{n}, @var{p})
-
-@c Uses a modular algorithm to compute @code{a^n mod m} where @var{a} and
-@c @var{n} are integers and @var{m} is a positive integer. If @var{n} is
-@c negative, @code{inv_mod} is used to find the modular inverse.
-
-Berechnet den Modulus @code{a^n mod p} der Exponentiation @code{a^n} zum Modul
-@var{p}. Die Argumente @var{a} und @var{n} m@"ussen ganze Zahlen sein. Das
-Modul @var{p} muss eine positive ganze Zahl sein. Ist @var{n} negativ, wird die
-Funktion @mref{inv_mod} aufgerufen, um das modulare Inverse zu berechnen.
-
-Die Funktion @code{power_mod} ist f@"ur ganze Zahlen @"aquivalent zu
-@code{mod(a^n, p)}. Der Algorithmus von @code{power_mod} ist besondere f@"ur
-gro@ss{}e ganze Zahlen effizienter.
-
-Siehe auch die Funktionen @mref{inv_mod} und @mrefdot{mod}
-
-Beispiele:
-
-@code{power_mod(a,n,p)} ist @"aquivalent zu @code{mod(a^n,p}. Das modulare
-Inverse wird mit der Funktion @code{inv_mod} berechnet.
-
-@example
-(%i1) power_mod(3, 15, 5);
-(%o1) 2
-(%i2) mod(3^15,5);
-(%o2) 2
-(%i3) power_mod(2, -1, 5);
-(%o3) 3
-(%i4) inv_mod(2,5);
-(%o4) 3
-@end example
-
-F@"ur gro@ss{}e ganze Zahlen ist @code{power_mod} effizienter. Das folgende
-Ergebnis kann nicht in einer vern@"unftigen Zeit mit @code{mod(a^n,p)} berechnet
-werden.
-
-@example
-(%i1) power_mod(123456789,123456789,987654321);
-(%o1) 598987215
-@end example
-@end deffn
-
@c --- 27.11.2010 DK -----------------------------------------------------------
@anchor{qunit}
@deffn {Funktion} qunit (@var{n})
@@ -643,18 +646,15 @@ Findet f@"ur das Argument @var{n} L@"osungen der Pellschen Gleichung
@end example
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{totient}
@deffn {Funktion} totient (@var{n})
-@c Returns the number of integers less than or equal to @var{n} which are
-@c relatively prime to @var{n}.
-
Gibt die Anzahl der ganzen Zahlen zur@"uck, die kleiner oder gleich @var{n}
-sind und die kein Teiler von @var{n} sind.
+und teilerfremd zu @var{n} sind.
@end deffn
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{zerobern}
@defvr {Optionsvariable} zerobern
Standardwert: @code{true}
@@ -664,11 +664,11 @@ Standardwert: @code{true}
@c See @code{bern} and @code{euler}.
Hat @code{zerobern} den Wert @code{false}, werden von den Funktionen @code{bern}
-die Bernoulli Zahlen und von @code{euler} die Euler Zahlen ausgeschlossen,
-die als Ergenis Null haben. Siehe @mref{bern} und @mrefdot{euler}
+diejenigen Bernoulli-Zahlen und von @code{euler} diejenigen Euler-Zahlen
+ausgeschlossen, die gleich Null sind. Siehe @mref{bern} und @mrefdot{euler}
@end defvr
-@c --- 27.11.2010 DK -----------------------------------------------------------
+@c --- 27.03.2012 VN -----------------------------------------------------------
@anchor{zeta}
@deffn {Funktion} zeta (@var{n})
@@ -698,13 +698,14 @@ $$\zeta\left(s\right)=\sum_{k=1}^{\infty }{{{1}\over{k^{s}}}}$$
@end example
@end ifnottex
-F@"ur negative ganze Zahlen @var{n}, Null und postive gerade ganze Zahlen
-vereinfacht @code{zeta} zu einem exakten Ergebnis. Damit diese Vereinfachung
-f@"ur positive ganze Zahlen ausgef@"uhrt wird, muss die Optionsvariable
-@code{zeta%pi} den Wert @code{true} haben. Siehe @mrefdot{zeta%pi} F@"ur
-einfache und gro@ss{}e Gleitkommazahlen hat @code{zeta} ein numerisches
-Ergebnis. F@"ur alle anderen Argumente einschlie@ss{}lich komplexe Zahlen und
-rationale Zahlen gibt @code{zeta} eine Substantivform zur@"uck. Hat die
+F@"ur negative ganze Zahlen @var{n}, Null und positive gerade ganze Zahlen
+wird @code{zeta} zu einem exakten Ergebnis vereinfacht.
+Damit diese Vereinfachung f@"ur positive ganze Zahlen ausgef@"uhrt wird,
+muss die Optionsvariable @code{zeta%pi} den Wert @code{true} haben.
+Siehe @mrefdot{zeta%pi}. F@"ur einfache und beliebig genaue Gleitkommazahlen
+(Typ @code{bfloat}) hat @code{zeta} ein numerisches Ergebnis.
+F@"ur alle anderen Argumente einschlie@ss{}lich der komplexen und
+rationalen Zahlen gibt @code{zeta} eine Substantivform zur@"uck. Hat die
Optionsvariable @code{zeta%pi} den Wert @code{false}, gibt @code{zeta} auch
f@"ur gerade ganze Zahlen eine Substantivform zur@"uck.
@@ -718,7 +719,7 @@ Grenzwerte @code{limit(zeta(x), x, 1, plus} und
@c The Riemann zeta function distributes over lists, matrices, and equations.
Die Riemannsche Zeta-Funktion wird auf die Argumente von Listen, Matrizen und
-Gleichungen angewendendet, wenn die Optionsvariable @code{distribute_over}
+Gleichungen angewendet, wenn die Optionsvariable @code{distribute_over}
den Wert @code{true} hat.
@c See also @code{bfzeta} and @code{zeta%pi}.
View
7 interfaces/emacs/imaxima/ChangeLog
@@ -1,3 +1,10 @@
+2012-03-25 Yasuaki Honda <yasuaki.honda@gmail.com>
+ * version 1.03
+ * A new command "reinit-imaxima" is added. This command reset the
+ communication status of Emacs Lisp and Maxima. When imaxima does
+ not respond to any input, this command will help to resolve such
+ situation.
+
2011-10-02 Yasuaki Honda <yasuaki.honda@gmail.com>
* version 1.01
* An old workaround code for tex prevented imaxima on Mac OS X
View
2  interfaces/emacs/imaxima/imaxima-autoconf-variables.el
@@ -19,6 +19,6 @@
;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
;; MA 02111-1307 USA
(defconst *imaxima-autoconf-package* "imaxima-imath")
-(defconst *imaxima-autoconf-version* "1.02")
+(defconst *imaxima-autoconf-version* "1.03")
(provide 'imaxima-autoconf-variables)
View
12 interfaces/emacs/imaxima/imaxima.el
@@ -420,6 +420,17 @@ dots per inch. Buffer-local to rendering buffer.")
(message "%s %s" *imaxima-autoconf-package* *imaxima-autoconf-version*))
;;
+;; Reset
+;;
+
+(defun reinit-imaxima ()
+ "Re-initialize imaxima"
+ (interactive)
+ (setq imaxima-filter-running nil
+ imaxima-output nil
+ continuation nil))
+
+;;
;; Geometry
;;
@@ -1174,6 +1185,7 @@ turns them on. Set `imaxima-use-maxima-mode-flag' to t to use
(switch-to-buffer imaxima-buffer)
(set-buffer imaxima-buffer))
(return-from imaxima t)))
+ (reinit-imaxima)
(unless (imaxima-image-type-available-p imaxima-image-type)
(error "Your version of Emacs does not support the image type %s"
imaxima-image-type))
View
9 interfaces/emacs/imaxima/imaxima.texi
@@ -223,6 +223,15 @@ package in the mini buffer. You should make sure the version
information when you want to make bug reports.
@end defun
+@defun reinit-imaxima
+Initialize the imaxima program. Sometimes you may encounter situations
+where imaxima does not repond to your input. This is caused by the
+inconsistency between Emacs Lisp and Maxima. Such situations can be
+resolved by using this command. After calling this command from the
+Emacs mini buffer, you should type simple Maxima expression such as
+1+2; to ensure that the imaxima does respond to you now.
+@end defun
+
@node Inline Graph
@chapter Inline Graph
View
5 src/ifactor/ifactor.lisp
@@ -221,7 +221,8 @@
and d = 3 then (+ d (aref *prime-diffs* i))
do
(when (> (* d d) n)
- (push `(,n 1) factors)
+ ;;(push `(,n 1) factors) replaced by workaround next line,
+ (push (list n 1) factors) ;; see bug report 3510983 (van_nek, 2012-03-27)
(when $ifactor_verbose (format t "small prime cofactor: ~A~%" n))
(return-from get-small-factors (values 1 factors)))
(loop with deg = 0
@@ -714,7 +715,7 @@
(defun power-mod (b n m)
(if (zerop n)
- 1
+ (mod 1 m)
(do ((res 1))
(())
(when (logbitp 0 n)
View
2  src/limits/limit.lisp
@@ -2670,7 +2670,7 @@ It appears in LIMIT and DEFINT.......")
(t '$und)))
(t '$und))))))
((eq arglim '$und) '$und)
- ((member arglim '($zeroa $zerob $ind) :test #'eq) arg)
+ ((member arglim '($zeroa $zerob $ind) :test #'eq) arglim)
;;;Ignore tanh(%pi/2*%I) and multiples of the argument.
(t
;; erf (or tanh) of a known value is just erf(arglim).
View
8 src/miscellaneous/expintegral.lisp
@@ -531,7 +531,7 @@
(format t "~& : z = ~A~%" z))
(cond
- ((and (> (realpart z) 0) (> (abs z) 1.0))
+ ((and (>= (realpart z) 0) (> (abs z) 1.0))
;; We expand in continued fractions.
(when *debug-expintegral*
(format t "~&We expand in continued fractions.~%"))
@@ -697,7 +697,8 @@
(format t "~& : z = ~A~%" z))
(cond
- ((and (eq ($sign ($realpart z)) '$pos)
+ ((and (or (eq ($sign ($realpart z)) '$pos)
+ (eq ($sign ($realpart z)) '$zero))
(eq ($sign (sub (cabs z) bigfloatone)) '$pos))
;; We expand in continued fractions.
(when *debug-expintegral*
@@ -775,7 +776,8 @@
(format t "~& : z = ~A~%" z))
(cond
- ((and (eq ($sign ($realpart z)) '$pos)
+ ((and (or (eq ($sign ($realpart z)) '$pos)
+ (eq ($sign ($realpart z)) '$zero))
(eq ($sign (sub (cabs z) bigfloatone)) '$pos))
;; We expand in continued fractions.
(when *debug-expintegral*
View
8 src/numerical-functions/intpol.lisp
@@ -70,7 +70,13 @@ Perhaps you meant to enter `~a'.~%"
(let ((lin 0) (a left) (b right)
(fa (convert (funcall f (maxima::to left))))
(fb (convert (funcall f (maxima::to right)))) c fc)
- (unless (and (numberp fa) (numberp fb))
+ (unless (numberp fa)
+ (maxima::merror (intl:gettext "find_root: function did not evaluate to a number at ~M")
+ a)
+ (return-from find-root-subr (values nil a b)))
+ (unless (numberp fb)
+ (maxima::merror (intl:gettext "find_root: function did not evaluate to a number at ~M")
+ b)
(return-from find-root-subr (values nil a b)))
(when (<= (abs fa) (to abserr))
;; If a or b is already small enough, return it as the root
View
294 src/rational-functions/numth.lisp
@@ -201,3 +201,297 @@
(defun gctime1 (a b)
(gctimes (car a) (cadr a) (car b) (cadr b)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Maxima functions:
+;; zn_order, zn_primroot_p, zn_primroot, zn_log, chinese
+;;
+;; 2012, Volker van Nek
+
+
+;; compute the order of x in (Z/nZ)*
+;;
+;; optional argument: ifactors of totient(n) as returned in Maxima by
+;; block([factors_only:false], ifactors(totient(n)))
+;; e.g. [[2, 3], [3, 1], ... ]
+;;
+(defmfun $zn_order (x n &optional fs-phi)
+ (unless (and (integerp x) (integerp n))
+ (return-from $zn_order
+ (if fs-phi
+ (list '($zn_order) x n fs-phi)
+ (list '($zn_order) x n) )))
+ (when (minusp x) (setq x (mod x n)))
+ (cond
+ ((= 0 x) nil)
+ ((= 1 x) (if (= n 1) nil 1))
+ ((/= 1 (gcd x n)) nil)
+ (t
+ (if fs-phi
+ (if (and ($listp fs-phi) ($listp (cadr fs-phi)))
+ (progn
+ (setq fs-phi (mapcar #'cdr (cdr fs-phi))) ; Lispify fs-phi
+ (setq fs-phi (cons (totient-from-factors fs-phi) fs-phi)) )
+ (merror (intl:gettext
+ "Third argument to `zn_order' must be of the form [[p1, e1], ..., [pk, ek]].")) )
+ (setq fs-phi (totient-with-factors n)) )
+ (zn_order x
+ n
+ (car fs-phi) ;; phi
+ (cdr fs-phi)) ))) ;; factors of phi with multiplicity
+;;
+(defun zn_order (x n phi fs-phi)
+ (let ((s phi) p e)
+ (dolist (f fs-phi s)
+ (setq p (car f) e (cadr f))
+ (setq s (/ s (expt p e)))
+ (do ((z (power-mod x s n)))
+ ((= z 1))
+ (setq z (power-mod z p n))
+ (setq s (* s p)) )) ))
+
+
+;; compute totient (euler-phi) of n and its factors in one function
+;;
+;; returns a list of the form (phi ((p1 e1) ... (pk ek)))
+;;
+(defun totient-with-factors (n)
+ (let (($factors_only) ($intfaclim) (phi 1) fs-n (fs) p e (fs-phi) g)
+ (setq fs-n (get-factor-list n))
+ (dolist (f fs-n fs)
+ (setq p (car f) e (cadr f))
+ (setq phi (* phi (1- p) (expt p (1- e))))
+ (when (> e 1) (setq fs (cons `(,p ,(1- e)) fs)))
+ (setq fs (append (get-factor-list (1- p)) fs)) )
+ (setq fs (copy-tree fs)) ;; this deep copy is a workaround to avoid references
+ ;; to the list returned by ifactor.lisp/get-factor-list.
+ ;; see bug 3510983
+ (setq fs (sort fs #'(lambda (a b) (< (car a) (car b)))))
+ (setq g (car fs))
+ (dolist (f (cdr fs) (cons phi (reverse (cons g fs-phi))))
+ (if (= (car f) (car g))
+ (incf (cadr g) (cadr f)) ;; assignment
+ (progn
+ (setq fs-phi (cons g fs-phi))
+ (setq g f) ))) ))
+
+;; recompute totient from given factors
+;;
+;; fs-phi: factors of totient with multiplicity: ((p1 e1) ... (pk ek))
+;;
+(defun totient-from-factors (fs-phi)
+ (let ((phi 1) p e)
+ (dolist (f fs-phi phi)
+ (setq p (car f) e (cadr f))
+ (setq phi (* phi (expt p e))) )))
+
+
+;; for n > 2 is x a primitive root modulo n
+;; when n does not divide x
+;; and for all prime factors p of phi = totient(n)
+;; x^(phi/p) mod n # 1
+;;
+;; optional argument: ifactors of totient(n)
+;;
+(defmfun $zn_primroot_p (x n &optional fs-phi)
+ (unless (and (integerp x) (integerp n))
+ (return-from $zn_primroot_p
+ (if fs-phi
+ (list '($zn_primroot_p) x n fs-phi)
+ (list '($zn_primroot_p) x n) )))
+ (when (minusp x) (setq x (mod x n)))
+ (cond
+ ((= 0 x) nil)
+ ((= 1 x) (if (= n 2) 1 nil))
+ ((<= n 2) nil)
+ ((= 0 (mod x n)) nil)
+ (t
+ (if fs-phi
+ (if (and ($listp fs-phi) ($listp (cadr fs-phi)))
+ (progn
+ (setq fs-phi (mapcar #'cdr (cdr fs-phi))) ; Lispify fs-phi
+ (setq fs-phi (cons (totient-from-factors fs-phi) fs-phi)) )
+ (merror (intl:gettext
+ "Third argument to `zn_primroot_p' must be of the form [[p1, e1], ..., [pk, ek]].")) )
+ (setq fs-phi (totient-with-factors n)) )
+ (zn-primroot-p x
+ n
+ (car fs-phi) ;; phi
+ (mapcar #'car (cdr fs-phi))) ))) ;; factors only (omitting multiplicity)
+;;
+(defun zn-primroot-p (x n phi fs-phi)
+ (unless (= 1 (gcd x n))
+ (return-from zn-primroot-p nil) )
+ (dolist (p fs-phi t)
+ (when (= 1 (power-mod x (/ phi p) n))
+ (return-from zn-primroot-p nil) )))
+
+;;
+;; find the smallest primitive root modulo n
+;;
+;; optional argument: ifactors of totient(n)
+;;
+(defmfun $zn_primroot (n &optional fs-phi)
+ (unless (integerp n)
+ (return-from $zn_primroot
+ (if fs-phi
+ (list '($zn_primroot) n fs-phi)
+ (list '($zn_primroot) n) )))
+ (cond
+ ((<= n 1) nil)
+ ((= n 2) 1)
+ (t
+ (if fs-phi
+ (if (and ($listp fs-phi) ($listp (cadr fs-phi)))
+ (progn
+ (setq fs-phi (mapcar #'cdr (cdr fs-phi))) ; Lispify fs-phi
+ (setq fs-phi (cons (totient-from-factors fs-phi) fs-phi)) )
+ (merror (intl:gettext
+ "Second argument to `zn_primroot' must be of the form [[p1, e1], ..., [pk, ek]].")) )
+ (setq fs-phi (totient-with-factors n)) )
+ (zn-primroot n
+ (car fs-phi) ;; phi
+ (mapcar #'car (cdr fs-phi))) ))) ;; factors only (omitting multiplicity)
+;;
+(defun zn-primroot (n phi fs-phi)
+ (do ((i 2 (1+ i)))
+ ((= i n) nil)
+ (when (zn-primroot-p i n phi fs-phi)
+ (return i)) ))
+
+;;
+;; Chinese Remainder Theorem
+;;
+(defmfun $chinese (rems mods)
+ (cond
+ ((not (and ($listp rems) ($listp mods)))
+ (list '($chinese) rems mods) )
+ ((or (= 0 ($length rems)) (= 0 ($length mods)))
+ (merror (intl:gettext
+ "At least one argument to `chinese' was an empty list." )))
+ ((notevery #'integerp (setq rems (cdr rems)))
+ (list '($chinese) (cons '(mlist simp) rems) mods) )
+ ((notevery #'integerp (setq mods (cdr mods)))
+ (list '($chinese) (cons '(mlist simp) rems) (cons '(mlist simp) mods)) )
+ (t
+ (car (chinese rems mods)) )))
+;;
+(defun chinese (rems mods)
+ (if (onep (length mods))
+ (list (car rems) (car mods))
+ (let* ((rp (car rems))
+ (p (car mods))
+ (rq-q (chinese (cdr rems) (cdr mods)))
+ (rq (car rq-q))
+ (q (cadr rq-q))
+ (q-inv (inv-mod q p))
+ (h (mod (* (- rp rq) q-inv) p))
+ (x (+ (* h q) rq)) )
+ (list x (* p q)) )))
+
+;;
+;; discrete logarithm:
+;; solve g^x = a mod n, where g is a generator of (Z/nZ)*
+;;
+;; see: lecture notes 'Grundbegriffe der Kryptographie' - Eike Best
+;; http://theoretica.informatik.uni-oldenburg.de/~best/publications/kry-Mai2005.pdf
+;;
+;; optional argument: ifactors of totient(n)
+;;
+(defmfun $zn_log (a g n &optional fs-phi)
+ (unless (and (integerp a) (integerp g) (integerp n))
+ (return-from $zn_log
+ (if fs-phi
+ (list '($zn_log) a g n fs-phi)
+ (list '($zn_log) a g n) )))
+ (when (minusp a) (setq a (mod a n)))
+ (cond
+ ((or (= 0 a) (>= a n)) nil)
+ ((= 1 a) 0)
+ ((= g a) 1)
+ (t
+ (if fs-phi
+ (if (and ($listp fs-phi) ($listp (cadr fs-phi)))
+ (progn
+ (setq fs-phi (mapcar #'cdr (cdr fs-phi))) ; Lispify fs-phi
+ (setq fs-phi (cons (totient-from-factors fs-phi) fs-phi)) )
+ (merror (intl:gettext
+ "Fourth argument to `zn_log' must be of the form [[p1, e1], ..., [pk, ek]].")) )
+ (setq fs-phi (totient-with-factors n)) )
+ (unless (zn-primroot-p g n (car fs-phi) (mapcar #'car (cdr fs-phi)))
+ (merror (intl:gettext "Second argument to `zn_log' must be a generator of (Z/~MZ)*.") n) )
+ (when (= 0 (mod (- a (* g g)) n))
+ (return-from $zn_log 2) )
+ (when (= 1 (mod (* a g) n))
+ (return-from $zn_log (mod -1 (car fs-phi))) )
+ (zn-dlog a
+ g
+ n
+ (car fs-phi) ;; phi
+ (cdr fs-phi)) ))) ;; factors with multiplicity
+;;
+;; Pohlig and Hellmann reduction:
+(defun zn-dlog (a g n phi fs-phi)
+ (let (p e phip gp x dlog (dlogs nil))
+ (dolist (f fs-phi)
+ (setq p (car f) e (cadr f))
+ (setq phip (/ phi p))
+ (setq gp (power-mod g phip n))
+ (if (= 1 e)
+ (setq x (dlog-rho (power-mod a phip n) gp p n))
+ (progn
+ (setq x 0)
+ (do ((agx a) (k 1) (pk 1)) (())
+ (setq dlog (dlog-rho (power-mod agx (/ phip pk) n) gp p n))
+ (setq x (+ x (* dlog pk)))
+ (if (= k e)
+ (return)
+ (setq k (1+ k) pk (* pk p)) )
+ (setq agx (mod (* a ($power_mod g (- x) n)) n)) )))
+ (setq dlogs (cons x dlogs)) )
+ (car (chinese (reverse dlogs) (mapcar #'(lambda (z) (apply #'expt z)) fs-phi))) ))
+;;
+;; brute-force:
+(defun dlog-naive (a g q n)
+ (decf q)
+ (do ((i 0 (1+ i)) (gi 1 (mod (* gi g) n)))
+ ((= gi a) i) ))
+;;
+;; Pollard rho for dlog computation:
+(defun dlog-rho (a g q n)
+ (cond
+ ((= 1 a) 0)
+ ((= g a) 1)
+ ((= 0 (mod (- a (* g g)) n)) 2)
+ ((= 1 (mod (* a g) n)) (1- q))
+ ((< q 512) (dlog-naive a g q n))
+ (t
+ (let (rnd (b 1) (y 0) (z 0) (bb 1) (yy 0) (zz 0) dy dz)
+ (dotimes (i 32 (progn (print "pollard-rho failed.") nil))
+ (do () (())
+ (multiple-value-setq (b y z) (dlog-f b y z a g q n))
+ (multiple-value-setq (bb yy zz) (dlog-f bb yy zz a g q n))
+ (multiple-value-setq (bb yy zz) (dlog-f bb yy zz a g q n))
+ (when (= b bb) (return)) )
+ (setq dy (mod (- y yy) q) dz (mod (- zz z) q))
+ (when (= 1 (gcd dz q))
+ (return (mod (* dy (inv-mod dz q)) q)) )
+ (setq rnd (1+ (random (1- q))))
+ (multiple-value-setq (b y z)
+ (values (mod (* a (power-mod g rnd n)) n) rnd 1) )
+ (multiple-value-setq (bb yy zz) (values b y z)) )))))
+;;
+;; iteration for Pollard rho:
+(defun dlog-f (b y z a g q n)
+ (let ((s (mod b 3)))
+ (cond
+ ((= 0 s)
+ (values (mod (* b b) n) (mod (ash y 1) q) (mod (ash z 1) q)) )
+ ((= 1 s)
+ (values (mod (* a b) n) y (mod (+ z 1) q)) )
+ (t
+ (values (mod (* g b) n) (mod (+ y 1) q) z) ))))
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
View
6 tests/rtest16.mac
@@ -2215,3 +2215,9 @@ closeto(elliptic_f(bfloat(%pi), .1b0) - 2*elliptic_kc(.1b0), 1e-16);
true;
closeto(elliptic_f(bfloat(%pi), .9b0) - 2*elliptic_kc(.9b0), 1e-16);
true;
+
+/*
+ * Bug 3509430: limit of tanh(x) at 0 makes no sense
+ */
+limit(tanh(x), x, 0);
+0;
View
8 tests/rtest_gamma.mac
@@ -3462,5 +3462,13 @@ closeto(
1b-60);
true;
+/* See Bug 3220128, but this isn't really that bug */
+closeto(
+ gamma_incomplete(0, 200b0*%i),
+ 0.00437844609302782567916569771749325524128345091344187598851110680706344144459295b0
+ - %i*.00241398745542678587253611621620491057595401709907514761094360488114169654741b0,
+ 3.4b-67);
+true;
+
(fpprec:oldfpprec,done);
done;
View
74 tests/rtest_numth.mac
@@ -0,0 +1,74 @@
+(kill(all), 0);
+0;
+
+/* (Z/pZ)* p prime */
+p : 2^127-1;
+170141183460469231731687303715884105727;
+
+fs : ifactors(p - 1);
+[[2, 1], [3, 3], [7, 2], [19, 1], [43, 1], [73, 1], [127, 1], [337, 1], [5419, 1], [92737, 1], [649657, 1], [77158673929, 1]];
+
+g : zn_primroot(p, fs);
+43;
+
+zn_primroot_p(power_mod(g, 7, p), p, fs);
+false;
+
+zn_primroot_p(power_mod(g, 11, p), p, fs);
+true;
+
+is(zn_order(g, p, fs) = totient(p));
+true;
+
+is(zn_order(power_mod(g, 7, p), p, fs) = zn_order(g, p, fs));
+false;
+
+is(zn_order(power_mod(g, 11, p), p, fs) = zn_order(g, p, fs));
+true;
+
+a : power_mod(g, 1234567890, p);
+151915201611216996495932583752378710518;
+
+zn_log(a, g, p, fs);
+1234567890;
+
+/* (Z/nZ)* n composite */
+n : 22;
+22;
+
+g : zn_primroot(n);
+7;
+
+zn_primroot_p(power_mod(g, 2, n), n);
+false;
+
+zn_primroot_p(power_mod(g, 3, n), n);
+true;
+
+zn_order(power_mod(g, 2, n), n);
+5;
+
+zn_order(g, n);
+10;
+
+a : power_mod(g, 8, n);
+9;
+
+zn_log(a, g, n);
+8;
+
+/* CRT */
+mods : [1009, 1013, 1019];
+[1009, 1013, 1019];
+
+x : 374599943;
+374599943;
+
+rems : map(lambda([z], mod(x, z)), mods);
+[621, 647, 258];
+
+chinese(rems, mods);
+374599943;
+
+(remvalue(p,fs,g,a,n,mods,x,rems), 0);
+0;
View
1  tests/testsuite.lisp
@@ -33,6 +33,7 @@
"rtest_scalarp"
"rtest_everysome"
"rtestint"
+ "rtest_numth"
"rtestifactor"
((mlist simp) "rtest_equal" 157 160)
"rtest_abs"
Please sign in to comment.
Something went wrong with that request. Please try again.