| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 21.1 Funktionen und Variablen der Zahlentheorie |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Gibt die n-te Bernoulli-Zahl der ganzen Zahl n zurück. Hat die
Optionsvariable zerobern den Wert false, werden Bernoulli-Zahlen
unterdrückt, die Null sind.
Siehe auch burn.
(%i1) zerobern: true$
(%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
1 1 1 1 1
(%o2) [1, - -, -, 0, - --, 0, --, 0, - --]
2 6 30 42 30
(%i3) zerobern: false$
(%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
1 1 1 5 691 7 3617 43867
(%o4) [1, - -, -, - --, --, - ----, -, - ----, -----]
2 6 30 66 2730 6 510 798
Gibt das n-te Bernoulli-Polynom in der Variablen x zurück.
Die Riemannsche Zeta-Funktion für das Argument s, die wie folgt definiert ist:
inf
====
\ 1
zeta(s) = > --
/ s
==== k
k = 1
bfzeta gibt einen Wert als große Gleitkommazahl zurück. Die Anzahl
der Stellen wird durch das Argument n angegeben.
Anstatt der Funktion bfzeta ist die Funktion zeta
zu bevorzugen,
die sowohl für reelle und komplexe Gleitkommazahlen und Gleitkommazahlen mit
eine beliebigen Genauigkeit die Riemannsche Zeta-Funktion berechnen kann.
Die Hurwitzsche Zeta-Funktion für die Argumente s und h, die wie folgt definiert ist:
inf
====
\ 1
zeta (s,h) = > --------
/ s
==== (k + h)
k = 0
bfhzeta gibt einen Wert als große Gleitkommazahl zurück. Die
Anzahl der Stellen wird durch das Argument n angegeben.
Gibt eine rational Zahl zurück, die eine Näherung für die n-te
Bernoulli Zahl für die ganze Zahl n ist. burn berechnet eine
Näherung als große Gleitkommatzahl mit der folgenden Beziehung:
n - 1 1 - 2 n
(- 1) 2 zeta(2 n) (2 n)!
B(2 n) = ------------------------------------
2 n
%pi
burn kann effizienter als die Funktion bern für große,
einzelne ganze Zahlen n sein, da bern zunächst alle Bernoulli
Zahlen bis n berechnet. burn ruft für ungerade ganze Zahlen und
Zahlen die kleiner oder gleich 255 die Funktion bern auf.
Das Kommando load(bffac) lädt die Funktion. Siehe auch bern.
divsum(n, k) potenziert die Teiler des Argumentes n
mit dem Argument k und gibt die Summe als Ergebnis zurück.
divsum(n) gibt die Summe der Teiler der Zahl n zurück.
(%i1) divsum (12); (%o1) 28 (%i2) 1 + 2 + 3 + 4 + 6 + 12; (%o2) 28 (%i3) divsum (12, 2); (%o3) 210 (%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2; (%o4) 210
Gibt die n-te Eulersche Zahl für eine nichtnegative ganze Zahl n zurück.
Für die Euler-Mascheroni Konstante siehe %gamma.
Beispiele:
(%i1) map (euler, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o1) [1, 0, - 1, 0, 5, 0, - 61, 0, 1385, 0, - 50521]
Gibt die n-te Fibonacci-Zahl zurück. Die Fibonacci-Folge ist rekursiv definiert:
fib(0) = 0 fib(1) = 1 fib(n) = fib(n-1) + fib(n-2)
Für negative ganze Zahlen kann die Fibonacci-Folge erweitert wird mit:
n + 1 fib(- n) = (- 1) f(n)
Nach einem Aufruf der Funktion fib(n), enthält die Systemvariable
prevfib die zur Zahl n vorhergehende Fibonacci-Zahl.
(%i1) map (fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o1) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
Fibonacci-Zahlen im Ausdruck expr werden durch die Goldene Zahl
%phi ausgedrückt. Siehe %phi.
Beispiele:
(%i1) fibtophi (fib (n));
n n
%phi - (1 - %phi)
(%o1) -------------------
2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2) - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);
n + 1 n + 1 n n
%phi - (1 - %phi) %phi - (1 - %phi)
(%o3) - --------------------------- + -------------------
2 %phi - 1 2 %phi - 1
n - 1 n - 1
%phi - (1 - %phi)
+ ---------------------------
2 %phi - 1
(%i4) ratsimp (%);
(%o4) 0
Faktorisiert eine positive ganze Zahl n. Sind n = p1^e1..pk^nk die
Faktoren der ganzen Zahl n, dann gibt ifactor das Ergebnis
[[p1, e1], ... , [pk, ek]] zurück.
Für die Faktorisierung kommen eine einfache Primfaktorzerlegung mit Primzahlen bis zu 9973, das Zählkörpersieb nach Pollard oder die Methode der Elliptischen Kurven zum Einsatz.
(%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
Returns a list [a, b, u] where u is the greatest
common divisor of n and k, and u is equal to
a n + b k. The arguments n and k
must be integers.
igcdex implements the Euclidean algorithm. See also gcdex.
The command load(gcdex) loads the function.
Examples:
(%i1) load(gcdex)$ (%i2) igcdex(30,18); (%o2) [- 1, 2, 6] (%i3) igcdex(1526757668, 7835626735736); (%o3) [845922341123, - 164826435, 4] (%i4) igcdex(fib(20), fib(21)); (%o4) [4181, - 2584, 1]
Gibt die ganzzahlige n-te Wurzel des Betrags von x zurück.
(%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$ (%i2) map (lambda ([a], inrt (10^a, 3)), l); (%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]
Berechnet das modulare Inverse von n zum Modul p. Das Argument
n muss eine ganze Zahl und das Modul p eine positive ganze Zahl
sein. inv_mod(n,p) gibt false zurück, wenn das modulare Inverse
nicht existiert. Das modulare Inverse existiert immer, wenn das Modul p
eine Primzahl ist.
Siehe auch die Funktionen power_mod
und mod.
Beispiele:
(%i1) inv_mod(3, 41); (%o1) 14 (%i2) ratsimp(3^-1), modulus=41; (%o2) 14 (%i3) inv_mod(3, 42); (%o3) false
Gibt die ganzzahlige Wurzel des Betrages von x zurück, wenn x eine ganze Zahl ist. Andernfalls wird eine Substantivform zurückgegeben.
Berechnet das Jacobi-Symbol für die Argumente p und q.
(%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$ (%i2) map (lambda ([a], jacobi (a, 9)), l); (%o2) [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]
Gibt den kleinsten gemeinsamen Teiler der Argumente zurück. Die Argumente können ganze Zahlen und allgemeine Ausdrücke sein.
Mit dem Kommando load(functs) wird die Funktion geladen.
Berechnet den Modulus x mod p des Arguments x zum Modul p.
x und p können ganze Zahlen, rationale Zahlen, Gleitkommazahlen
oder allgemeine Ausdrücke sein.
Sind x und p reelle Zahlen und ist p ungleich Null, gibt
mod(x, p) das Ergebnis von x - p *
floor(x / p) zurück. Weiterhin gilt für alle reellen Zahlen
mod(x, 0) = x. Für eine Diskussion dieser Definition siehe
Kapitel 3.4, "Concrete Mathematics" von Graham, Knuth, and Patashnik. Die
Funktion mod(x, 1) ist eine Sägezahnfunktion mit der Periode 1
mit mod(1, 1) = 0 und mod(0, 1) = 0.
Der Hauptwert einer komplexen Zahl, die im Intervall (-%pi, %pi) liegt,
kann mit %pi - mod(%pi - x, 2*%pi) bestimmt werden, wobei x
die komplexe Zahl ist.
Wie für die Funktionen floor oder ceiling werden konstante
Ausdrücke, wie zum Beispiel 10 * %pi, in große Gleitkommazahlen
umgewandelt, um mod zu berechnen. Diese Umwandlung kann zu Fehlern
führen.
Für nicht nummerische Argumente x oder y kennt mod
verschiedene Vereinfachungen.
Siehe auch die Funktionen power_mod
und inv_mod.
Beispiele:
Zeige für zwei große ganze Zahlen, dass für das modulare Rechnen die
Regel mod(a+b,p) = mod(a,p)+mod(b,p) gilt.
(%i1) a:random(10^20)+10^19; (%o1) 72588919020045581148 (%i2) b:random(10^20)+10^19; (%o2) 35463666253140008825 (%i3) p:random(10^20)+10^19; (%o3) 39127433614020247557 (%i4) mod(a+b,p); (%o4) 29797718045145094859 (%i5) mod(mod(a,p)+mod(b,p),p); (%o5) 29797718045145094859
Vereinfachung für nicht nummerische Argumente.
(%i1) mod (x, 0); (%o1) x (%i2) mod (a*x, a*y); (%o2) a mod(x, y) (%i3) mod (0, x); (%o3) 0
Gibt die kleinste Primzahl zurück, die der Zahl n folgt.
(%i1) next_prime(27); (%o1) 29
Führt einen Test auf eine Primzahl für das Argument n durch. Hat
primep das Ergebnis false, ist n keine Primzahl. Ist das
Ergebnis true, ist n mit großer Wahrscheinlichkeit eine
Primzahl.
Für ganze Zahlen n die kleiner als 10^16 sind wird eine probalistisches
Miller-Rabin-Verfahren. Hat in diesem Fall primep das Ergebnis
true, dann ist n eine Primzahl.
Für ganze Zahlen n größer als 10^16 nutzt primep den
Pseudo-Primzahlentest nach Miller-Rabin mit primep_number_of_tests
Tests
und den Pseudo_Primzahlentest nach Lucas. Die Wahrscheinlichkeit, dass eine
Zahl n den Pseudo-Primzahlentest nach Miller-Rabin passiert, ist kleiner
als 1/4. Mit dem Standardwert 25 für die Optionsvariable
primpe_number_of_tests ist die Wahrscheinlichkeit viel kleiner als
10^-15.
Standardwert: 25
Die Anzal der Pseudo-Primzahlentests nach Miller-Rabin der Funktion
primep.
Gibt die größte Primzahl zurück, die kleiner als die Zahl n ist.
(%i1) prev_prime(27); (%o1) 23
Berechnet den Modulus a^n mod p der Exponentiation a^n zum Modul
p. Die Argumente a und n müssen ganze Zahlen sein. Das
Modul p muss eine positive ganze Zahl sein. Ist n negativ, wird die
Funktion inv_mod
aufgerufen, um das modulare Inverse zu berechnen.
Die Funktion power_mod ist für ganze Zahlen äquivalent zu
mod(a^n, p). Der Algorithmus von power_mod ist besondere für
große ganze Zahlen effizienter.
Siehe auch die Funktionen inv_mod
und mod.
Beispiele:
power_mod(a,n,p) ist äquivalent zu mod(a^n,p. Das modulare
Inverse wird mit der Funktion inv_mod berechnet.
(%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
Für große ganze Zahlen ist power_mod effizienter. Das folgende
Ergebnis kann nicht in einer vernünftigen Zeit mit mod(a^n,p) berechnet
werden.
(%i1) power_mod(123456789,123456789,987654321); (%o1) 598987215
Findet für das Argument n Lösungen der Pellschen Gleichung
a^2 - n b^2 = 1.
(%i1) qunit (17); (%o1) sqrt(17) + 4 (%i2) expand (% * (sqrt(17) - 4)); (%o2) 1
Gibt die Anzahl der ganzen Zahlen zurück, die kleiner oder gleich n sind und die kein Teiler von n sind.
Standardwert: true
Hat zerobern den Wert false, werden von den Funktionen bern
die Bernoulli Zahlen und von euler die Euler Zahlen ausgeschlossen,
die als Ergenis Null haben. Siehe bern
und euler.
Die Riemannsche Zeta-Funktion für s, die wie folgt definiert ist:
inf
====
\ 1
zeta(s) = > --
/ s
==== k
k = 1
Für negative ganze Zahlen n, Null und postive gerade ganze Zahlen
vereinfacht zeta zu einem exakten Ergebnis. Damit diese Vereinfachung
für positive ganze Zahlen ausgeführt wird, muss die Optionsvariable
zeta%pi den Wert true haben. Siehe zeta%pi.
Für
einfache und große Gleitkommazahlen hat zeta ein numerisches
Ergebnis. Für alle anderen Argumente einschließlich komplexe Zahlen und
rationale Zahlen gibt zeta eine Substantivform zurück. Hat die
Optionsvariable zeta%pi den Wert false, gibt zeta auch
für gerade ganze Zahlen eine Substantivform zurück.
zeta(1) ist nicht definiert. Maxima kennt jedoch die einseitigen
Grenzwerte limit(zeta(x), x, 1, plus und
limit(zeta(x), x, 1, minus.
Die Riemannsche Zeta-Funktion wird auf die Argumente von Listen, Matrizen und
Gleichungen angewendendet, wenn die Optionsvariable distribute_over
den Wert true hat.
Siehe auch bfzeta
und zeta%pi.
Beispiele:
(%i1) zeta([-2,-1,0,0.5,2,3,1+%i]);
2
1 1 %pi
(%o1) [0, - --, - -, - 1.460354508809586, ----, zeta(3),
12 2 6
zeta(%i + 1)]
(%i2) limit(zeta(x),x,1,plus);
(%o2) inf
(%i3) limit(zeta(x),x,1,minus);
(%o3) minf
Standardwert: true
Hat zeta%pi den Wert true, vereinfacht die Funktion zeta(n)
für gerade ganzen Zahlen n zu einem Ergebnis, das proportional zu
%pi^n ist. Ansonsten ist das Ergebnis von zeta eine
Substantivform für gerade ganze Zahlen.
Beispiele:
(%i1) zeta%pi: true$
(%i2) zeta (4);
4
%pi
(%o2) ----
90
(%i3) zeta%pi: false$
(%i4) zeta (4);
(%o4) zeta(4)
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.