# filonenko-mikhail/embeddable-maxima

### Subversion checkout URL

You can clone with HTTPS or Subversion.

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

…ima/maxima into quicklisp
commit 0b7086d5bea1642678fc56dadede92fe530fd1ae 2 parents ef8788f + 2f2fac9
authored
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
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}.
7 interfaces/emacs/imaxima/ChangeLog
 @@ -1,3 +1,10 @@ +2012-03-25 Yasuaki Honda + * 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 * version 1.01 * An old workaround code for tex prevented imaxima on Mac OS X
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)
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))
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
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) 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). 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* 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 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) )))) +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
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;
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;
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;
1  tests/testsuite.lisp
 @@ -33,6 +33,7 @@ "rtest_scalarp" "rtest_everysome" "rtestint" + "rtest_numth" "rtestifactor" ((mlist simp) "rtest_equal" 157 160) "rtest_abs"