imported>Bithisarea: /* growthexperiments-addlink-summary-summary:2|1|0 */

2025-01-12T20:19:37Z

growthexperiments-addlink-summary-summary:2|1|0

Neue Seite

Die '''Kongruenzgeneratoren''' bilden eine Klasse von [[Algorithmus|Algorithmen]], die [[Zufallszahl|zufällig]] aussehende [[Folge (Mathematik)|Zahlenfolgen]] erzeugen. Die dadurch erzeugten Zahlen nennt man [[Pseudozufall]]szahlen, da sie [[Determinismus (Algorithmus)|deterministisch]] erzeugt werden und somit nicht wirklich [[Zufall|zufällig]] sind. Kongruenzgeneratoren sind die bekanntesten und meistverwendeten [[Arithmetischer Zufallszahlengenerator|rekursiven arithmetischen Zufallszahlengeneratoren]].

== Allgemeiner Kongruenzgenerator ==
Ein Kongruenzgenerator wird durch folgende Parameter definiert:
* Anzahl <math>n \in \mathbb{N}^+</math> der Zustandswerte
* Modul <math>m \in \{2, 3, 4, \ldots\}</math>
* Faktoren <math>a_1, \ldots, a_n \in \left\{ 0, \ldots, m-1 \right\}</math> mit <math>a_n > 0</math>
* Inkrement <math>b \in \left\{ 0, \ldots, m-1 \right\}</math>
* Startwerte <math>y_1, \ldots, y_n \in \left\{ 0, \ldots, m-1 \right\}</math> (nicht alle 0, wenn <math>b = 0</math>)

Für <math>i > n</math> setzt man nun
:<math>y_i = \left( \left(\sum_{k=1}^{n} a_k y_{i-k} \right) + b \right) \, \bmod \, m</math>. Dabei bezeichnet <math> \mod{} </math> den Divisionsrest; siehe [[Division mit Rest#Modulo|Modulo]].

Die so berechneten <math>y_i</math> werden als Zufallszahlen verwendet.

Der Zustand des Generators vor der Erzeugung von <math>y_i</math> wird durch die Werte <math>y_{i-n}, \ldots, y_{i-1}</math> gegeben. Dieser Zustand legt (bei gegebenen <math>n,m,a_k,b</math>) alle folgenden Zufallszahlen fest, da die nächste Zufallszahl und der nächste Zustand durch den aktuellen Zustand determiniert werden. Es gibt <math>m^n</math> mögliche Zustände, und deshalb muss spätestens nach <math>m^n</math> Schritten ein früherer Zustand wiederholt werden. Der Kongruenzgenerator erzeugt somit eine [[Periodizität (Mathematik)|periodische]] Folge von Zahlen, wobei die Periodenlänge auch wesentlich kleiner als <math>m^n</math> sein kann. Im Extremfall ist sie 1, und der Generator erzeugt immer die gleiche „Zufallszahl“. Bei der Festlegung der Parameter kommt es somit unter anderem darauf an, eine ausreichende Periodenlänge sicherzustellen.

Braucht man reelle Zufallszahlen im Intervall <math>[0, 1)</math>, so kann man dafür die Näherung
:<math>u_i := \frac{y_i}{m}</math>
verwenden, falls der Modulo <math>m</math> groß genug ist, um eine ausreichend feine Unterteilung zu ergeben.

== Linearer Kongruenzgenerator ==
Mit <math>n = 1</math> erhält man den Sonderfall eines '''linearen Kongruenzgenerators'''. Bei <math>b = 0</math> wird er als ''multiplikativer Kongruenzgenerator'' bezeichnet, und für andere <math>b</math> als ''gemischter linearer Kongruenzgenerator''.

Letzterer wird häufiger verwendet und hat vier [[natürliche Zahl]]en als Parameter:
* Modul <math>m \in \{2, 3, 4, \ldots\}</math>
* Faktor <math>a \in \{1, \ldots , m-1\}</math>
* Inkrement <math>b \in \{1, \ldots , m-1\}</math>
* Startwert <math>y_1 \in \{0, \ldots , m-1\}</math>

Aus dem Startwert werden dann die weiteren Werte nach folgender Formel (mit <math> i \ge 2 </math>) berechnet:
:<math>y_i = (a y_{i-1} + b) \ \bmod \ m </math>

Der lineare Kongruenzgenerator wurde 1949 von [[Derrick Henry Lehmer]] eingeführt.<ref name="KNUTH">[[Donald E. Knuth]]: ''[[The Art of Computer Programming]]. Volume 2: Seminumerical Algorithms.'' 3. Auflage. Addison-Wesley, 1997, ISBN 0-201-89684-2, S. 10–26</ref> Er wird in den Laufzeitbibliotheken verschiedener [[Programmiersprache]]n zur Erzeugung von Pseudozufallszahlen verwendet, z. B. in [[C (Programmiersprache)|C]]/[[C++]] in der [[Funktion (Programmierung)|Funktion]] ''rand()'' in der Headerdatei stdlib.h.<ref>Stackoverflow-Forum: [https://stackoverflow.com/questions/6793065/understanding-the-algorithm-of-visual-cs-rand-function ''Understanding the algorithm of Visual C++'s rand() function'']</ref>

In der [[Kryptographie]] dagegen kommt der lineare Kongruenzgenerator nicht zum Einsatz, da man schon aus wenigen Werten der erzeugten Zahlenfolge die Parameter <math>a</math> und <math>b</math> und damit die vollständige Zahlenfolge berechnen kann.

=== Periodenlänge ===
Lineare Kongruenzgeneratoren erreichen nach dem ''Satz von Knuth'' genau dann ihre maximal mögliche Periodenlänge <math>m</math>, wenn die folgenden Voraussetzungen erfüllt sind:
* Das Inkrement <math>b</math> ist zum Modul <math>m</math> [[Teilerfremdheit|teilerfremd]].
* Jeder [[Primfaktorzerlegung|Primfaktor]] von <math>m</math> teilt <math>a-1</math>.
* Wenn <math>m</math> durch 4 teilbar ist, dann auch <math>a-1</math>.

In diesem Fall erzeugt der Generator jede Zahl von 0 bis <math>m-1</math> genau einmal und beginnt dann wieder von vorn. Er liefert also eine [[Zufällige Permutation|pseudozufällige Permutation]] dieser Zahlen. Der Startwert <math>y_1</math> kann dann jede Zahl aus dieser Menge sein.

Der ''multiplikative Kongruenzgenerator'' (mit <math>b=0</math>) muss somit eine Periodenlänge kleiner als <math>m</math> haben. Der [[Satz von Carmichael]] besagt: bei gegebenem <math>m</math> ist seine Periodenlänge genau dann maximal, wenn gilt:
* <math>y_1</math> ist zu <math>m</math> teilerfremd,
* <math>a</math> ist ein [[Primitivwurzel|primitives Element]] modulo <math>m</math>.
Für einige Sonderfälle von <math> m </math> können die primitiven Elemente modulo <math> m </math> leicht bestimmt werden:
* Ist <math>m</math> eine [[Potenz (Mathematik)#Spezielle Potenzen|Zweierpotenz]] <math> \ge 16</math>, dann muss <math>a</math> mod 8 den Rest 3 oder 5 liefern. Die Periodenlänge ist dann <math>m/4</math>, und der Startwert <math> y_1 </math> muss ungerade sein. Es gibt zwei Perioden, die jeweils die Hälfte der ungeraden Zahlen von <math>1</math> bis <math>m-1</math> umfassen.
* Wenn <math>m</math> eine [[Primzahl]] <math> \ge 3</math> ist, dann muss für alle Primfaktoren <math>q</math> von <math>m-1</math> gelten: <math>a^{(m-1)/q} \ \bmod \ m \ne 1</math>. Dann beträgt die Periodenlänge <math>m - 1</math>. Der Startwert <math> y_1 </math> darf nicht Null sein.

=== Mängel der erzeugten Zahlen ===
Der lineare Kongruenzgenerator liefert keine vollkommen zufällig erscheinenden Zahlen. Man kann nachweisen, dass eine Abhängigkeit von aufeinanderfolgenden Zahlen besteht.

==== Teilperiode ====
Oft wählt man <math>m = 2^e</math>, wobei <math>e</math> die Wortlänge des Rechners in [[Bit]] ist, denn dann muss man die Modulo-Division nicht explizit berechnen. Sie ergibt sich von selbst durch das Abschneiden der Überlauf-Bits. In diesem Fall verhalten sich die <math>x</math> niederwertigsten Bits der Zustandszahl <math>y_i</math> wie ein Generator mit dem Modul <math>2^x</math>. Diese Bits wiederholen sich also spätestens nach <math>2^x</math> Schritten. Dies bedeutet insbesondere, dass das niederwertigste Bit bestenfalls die Periode 2 besitzt, also regelmäßig zwischen 0 und 1 wechselt. Beim multiplikativen Kongruenzgenerator ist es sogar konstant.

Allgemein gilt für alle linearen Kongruenzgeneratoren: wenn <math>d</math> ein Teiler des Moduls <math>m</math> ist, dann ergibt <math>y_i \ \bmod \ d</math> eine Zahlenfolge mit der Periode <math>o \le d</math>:
: für ein <math> o \in \{1, \ldots, d\} </math> gilt: <math> \forall i: y_{i+o} \equiv y_i \ ( \bmod \ d) </math>.
Wenn der Generator nach dem Satz von Knuth die Periode <math>m</math> hat, dann beträgt die Länge <math>o</math> der Teilperiode genau <math> d </math> für alle Teiler <math>d</math> von <math>m</math>.

Wegen dieses Teilperioden-Verhaltens ist es ungünstig, Zufallszahlen <math>r_i \in \{0, \ldots, k-1\} </math> durch <math> r_i := y_i \ \bmod \ k </math> zu gewinnen, wenn <math>k</math> und <math>m</math> nicht teilerfremd sind. Dann würde der Divisionsrest <math> r_i \ \bmod \ d </math> für eine Zahl <math>d</math>, die <math>k</math> und <math>m</math> teilt, eine Periode der Länge höchstens <math>d</math> durchlaufen. Wenn man z. B. einen sechsseitigen [[Spielwürfel|Würfel]] simulieren will und <math>m </math> gerade ist, dann liefert <math> r_i := y_i \ \bmod \ 6 </math> Zahlen, die abwechselnd gerade und ungerade sind.

Mögliche Abhilfe:
* Man nutzt einen gemischten linearen Kongruenzgenerator mit Periode <math>m</math>, wobei man den Modul <math>m</math> zu <math>k</math> teilerfremd wählt. Die Ergebnisse <math> r_i := y_i \ \bmod \ k </math> sind nicht gleichverteilt, aber bei <math>k \ll m</math> ist die Abweichung von der Gleichverteilung nur gering und kann oft vernachlässigt werden.
* Man nutzt einen multiplikativen Kongruenzgenerator mit Periode <math>m-1</math> und wählt für <math>m</math> eine große Primzahl. Wenn außerdem <math>m-1</math> ein Vielfaches von <math>k</math> ist, sind die <math>r_i</math> auch gleichverteilt.
* Man setzt <math>m = 2^e</math> und wendet mit den höchstwertigen Bits von <math>y_i</math> eine [[Verwerfungsmethode]] an. Die <math>y_i</math> werden um <math>e-f</math> Bit nach rechts [[Bitweiser Operator#Bitweise Verschiebungen|geschoben]], wobei <math> 2^f</math> die kleinste Zweierpotenz <math> \ge k</math> ist: <math> r_i := \lfloor y_i / 2^{e-f} \rfloor </math>. Dabei verwendet man nur die <math> r_i < k </math>, die übrigen werden verworfen. Diese Methode liefert gleichverteilte Ergebnisse.
* Man berechnet <math> r_i := y_i \ \bmod \ x </math>, wobei <math> x </math> die kleinste zu <math> m </math> teilerfremde Zahl <math> \ge k </math> ist, und <math>r_i \ge k</math> werden verworfen.
* Manche Implementierungen eines linearen Kongruenzgenerators umgehen das Problem, indem sie nur den höherwertigen Teil des Zustandswertes <math>y_i</math> als Ergebnis liefern. Z. B. ist <math>m = 2^e</math> und das dem Nutzer gelieferte Ergebnis ist <math>\lfloor y_i / 2^b \rfloor</math> mit <math>2b = e</math>.

==== Hyperebenen-Verhalten ====
[[Datei:Lcg 3d.gif|mini|„Hyperebenenverhalten“ eines linearen Kongruenzgenerators in drei Dimensionen]]
[[Datei:TI59 3d.jpg|mini|Gemischter Kongruenzgenerator: <math>x_{n+1} = 24298x_n + 99991\ \bmod\ 199017</math>. Dieser Generator wird im [[TI-59]] von [[Texas Instruments]] verwendet. Gezeigt werden überlappende Tripel, d. h., <math>(x_1,x_2,x_3)</math>, <math>(x_2,x_3,x_4)</math>, <math>(x_3,x_4,x_5)</math> etc. Ohne Überlappungen bliebe nur jede dritte Ebene übrig.]]
Der lineare Kongruenzgenerator weist ein [[Hyperebene]]n-Verhalten auf, siehe [[Satz von Marsaglia]]. Durch geeignete Wahl der Parameter <math>m</math>, <math>a</math> und <math>b</math> kann man das Verhalten des Generators optimieren und eine große Zahl von Hyperebenen erreichen. Bei gegebenem <math>m</math> kann man <math>a</math> nach folgenden Faustregeln bilden:
* <math>a</math> sollte weder zu groß noch zu klein sein, etwa: <math>0{,}01 \cdot m < a < 0{,}99 \cdot m</math>
* <math>a</math> sollte möglichst zufällig gewählt werden, also nicht in [[Dualsystem|dualer]] oder [[Dezimalsystem|dezimaler]] Darstellung eine „runde“ Zahl sein.
* Beim gemischten linearen Kongruenzgenerator sollte die ''Potency'' möglichst groß sein. Sie ist der minimale Wert <math>s</math>, für den <math>(a-1)^s</math> ein Vielfaches von <math>m</math> ist. [[Donald E. Knuth]] empfiehlt, dass die Potency mindestens 5 sein sollte. Wenn <math>m = 2^e</math>, dann sollte <math> a \ \bmod \ 8 = 5</math> sein, um die maximal mögliche Potency <math>\lceil e/2 \rceil</math> zu erhalten.

Wenn man sichergehen will, dass der Generator gute Zufallszahlen erzeugt, sollte man sich nicht allein auf diese Faustregeln verlassen, sondern den Generator mit dem [[Spektraltest]] prüfen.

Wegen des Hyperebenen-Verhaltens greift man statt auf den linearen Kongruenzgenerator gelegentlich auf den [[Inverser Kongruenzgenerator|inversen Kongruenzgenerator]] zurück, der dieses Problem nicht aufweist. Allerdings erfordert er einen höheren Rechenaufwand. Er ist kein Spezialfall des allgemeinen Kongruenzgenerators.

=== Programmierung ===
Das folgende [[Programmiersprache|Programm]] in der [[Programmiersprache]] [[C++]] implementiert einen linearen Kongruenzgenerator mit <math>m=2^{64}</math>, <math>a=6364136223846793005</math> und <math>b=2531011</math>, der nur die 32 höchstwertigen Bits jeder erzeugten Zufallszahl ausgibt und die niederwertigen, die von geringerer Qualität sind, verwirft. Das Programm erzeugt 10 [[Zufallszahl]]en, die in einem [[Feld (Datentyp)|Array]] gespeichert und anschließend auf der Konsole ausgegeben werden.<ref>Rosetta Code: [https://rosettacode.org/wiki/Linear_congruential_generator Linear congruential generator]</ref><ref>GeeksforGeeks: [https://www.geeksforgeeks.org/linear-congruence-method-for-generating-pseudo-random-numbers/ Linear Congruence method for generating Pseudo Random Numbers]</ref>
<syntaxhighlight lang="c++">
#include <iostream>
#include <stdint.h>
using std::cout;
using std::endl;

// Funktion, die die Zufallszahlen erzeugt
void linearCongruentialGenerator(uint64_t &y, uint32_t *randNumbers, int count)
{
const uint64_t a = 6364136223846793005;
const uint64_t b = 2531011;
uint64_t r = y; // lokale Variable für die Berechnung
for (int i = 0; i < count; i++) {
r = a * r + b;
randNumbers[i] = r >> 32;
}
y = r; // Zustand zurückschreiben
}

int main()
{
const int count = 10; // Anzahl der Zufallszahlen
uint32_t randNumbers[count]; // Array für die Zufallszahlen
const uint64_t seed = 12345; // Startwert für den Generator

uint64_t y = seed; // Zustand des Generators
linearCongruentialGenerator(y, randNumbers, count); // Erzeugung der Zufallszahlen

for (int i = 0; i < count; i++) {
cout << randNumbers[i] << endl; // Ausgabe auf der Konsole
}
}
</syntaxhighlight>

== Fibonacci-Generator ==
Ein '''Fibonacci-Generator''' ist ebenfalls ein Kongruenzgenerator (mit <math>n=2</math>, <math>b=0</math> und <math> a_1 = a_2 = 1</math>) und besteht aus folgenden Komponenten:
* Modul <math>m \in \{2, 3, 4, \dotsc\}</math>
* Startwerte <math>y_1, y_2 \in \{ 0, \dotsc, m-1 \} </math>
Es sollte <math>\operatorname{ggT}(m,y_1,y_2) = 1</math> sein.

Mit folgender Bildungsregel werden die Pseudozufallszahlen erzeugt:
: <math>y_i = ( y_{i-1} + y_{i-2} ) \bmod m \quad (\text{mit } i \ge 3)</math>

Eine Eigenschaft ist, dass die Fälle <math>y_{i-1} < y_{i+1} < y_i</math> bzw. <math>y_i < y_{i+1} < y_{i-1}</math> nie auftreten. Fibonacci-Generatoren sind daher als Pseudozufallszahlengeneratoren wenig geeignet. Das gilt insbesondere für [[Mathematisches Objekt|mathematische Objekte]], zu deren Erzeugung mehr als zwei Zufallszahlen erforderlich sind. Würde man beispielsweise damit versuchen, eine zufällige Punktewolke in einem Würfel zu generieren, so kämen alle Punkte auf zwei Ebenen zu liegen.

== Verzögerter Fibonacci-Generator ==
Das Prinzip des Fibonacci-Generators kann aber verallgemeinert werden, indem man nicht die beiden letzten, sondern weiter zurückliegende Zustandswerte <math>y_i</math> zur Erzeugung der neuen Zufallszahl verwendet. Dies ergibt einen ''verzögerten (engl. 'lagged') Fibonacci-Generator'':
: <math>y_i = ( y_{i-B} + y_{i-A} ) \bmod m \quad \text{mit } A,B \in \N^+, \ A > B; \quad i > A</math>
: mit den Startwerten <math>y_1, \dotsc, y_A \in \{ 0, \dotsc, m-1 \}</math>

Dann ist also <math>n=A</math> und <math>a_A = a_B = 1</math>, die übrigen <math>a_k</math> sind Null. Dabei wählt man in der Regel <math>m</math> gerade und <math>A</math> und <math>B</math> so, dass das Polynom in <math>x</math>
: <math> x^A + x^B + 1 </math>
ein ''primitives Polynom modulo 2'' ist. Dann beträgt die Periodenlänge des Generators mindestens <math> 2^A - 1 </math>.

Die folgende Tabelle gibt einige Wertepaare für <math>A</math> und <math>B</math> an, die diese Bedingung erfüllen:

{| class="wikitable"
|-
! ''A''
| 2|| 31|| 55|| 73|| 98|| 100|| 135|| 258|| 607|| 3217|| 23209
|-
! ''B''
| 1|| 13|| 24|| 25|| 27|| 37|| 22|| 83|| 273|| 576|| 9739
|}

<math> x^A + x^B + 1 </math> ist genau dann ein ''primitives Polynom modulo 2'', wenn dies für <math> x^A + x^{A-B} + 1 </math> gilt. Somit kann man statt <math>B</math> immer auch <math>A-B</math> verwenden.

Dieser Generator wird auch praktisch eingesetzt. Er liefert aber ebenfalls keine vollkommen zufällig erscheinenden Zahlen. Das Problem des einfachen Fibonacci-Generators wird nur verlagert: Man hat niemals <math> y_{i-A} < y_i < y_{i-B} </math> oder <math> y_{i-B} < y_i < y_{i-A} </math>. Außerdem gibt es noch weitere Mängel.

Als Abhilfe wurde vorgeschlagen, immer nur <math>A</math> aufeinanderfolgende Zahlen zu verwenden, und dann die nächsten <math>4 A</math> bis <math>10 A</math> Zahlen zu verwerfen. Dies funktioniert gut, aber um den Preis eines 5- bis 11-mal höheren Rechenaufwands. Der von Donald Knuth vorgeschlagene Generator ''ranarray'' arbeitet auf diese Weise. Bei ihm ist <math>A = 100</math> und <math>B = 37</math>, und von 1009 aufeinanderfolgenden Zahlen wird immer nur ein Block von 100 Zahlen verwendet.

Um die Periode <math> 2^A - 1 </math> sicherzustellen, kommt es nur auf das jeweils niederwertigste Bit in den Zustandswerten <math> y_i </math> an, also darauf, ob sie gerade oder ungerade sind. Man kann die höherwertigen Bits beliebig modifizieren, um die Qualität der erhaltenen Zufallszahlen zu verbessern. Beispielsweise:

: <math> y_i = (y_{i-A} + y_{i-B} + f(y_{i-C})) \bmod m; \quad f\colon \{0, \dotsc, m-1\} \to \{0, 2, 4, 6, \dotsc\}, \; C \in \{ 1, \dotsc, n \} </math>

== Andere ==
Man kann den verzögerten Fibonacci-Generator weiter verallgemeinern, indem man mehr als zwei Zustandswerte verarbeitet:
: <math> y_i = \left( \sum_{k \in M} y_{i-k} \right) \bmod m \quad \text{mit} \quad M \subset \N^+ </math>.
<math>n</math> ist hier das größte Element in <math>M</math>. Um eine Periode von mindestens <math> 2^n-1 </math> zu garantieren, muss auch hier das entsprechende Polynom
: <math> \sum_{k \in M} x^k + 1 </math> oder gleichbedeutend das Polynom <math> x^n + \sum_{k \in M} x^{n-k} </math>
ein ''primitives Polynom modulo 2'' sein (mit geradem Modul <math>m</math>). Ein so konstruierter Generator mit <math> |M| > 2 </math> liefert im Allgemeinen bessere Zufallszahlen als mit <math> |M| = 2 </math>, aber wiederum um den Preis eines höheren Rechenaufwands.

Mit einer weiteren Verallgemeinerung kann man bei gegebenem <math> n </math> die Periodenlänge vergrößern und wohl auch die Qualität der Zufallszahlen weiter verbessern. <math>p</math> sei ein Primfaktor von <math>m</math>. für die Berechnungsvorschrift
: <math> y_i = \left( \sum_{k = 1}^{n} a_k y_{i-k} \right) \bmod m </math>
werden die <math> a_k \in \{ 0, \dotsc, m-1 \} </math> derart gewählt, mit <math> a_n \not\equiv 0 \pmod p </math>, dass das Polynom in <math>x</math>
: <math> x^n - \sum_{k=1}^{n} (a_k \bmod p) x^{n-k} </math>
ein ''primitives Polynom modulo <math>p</math>'' ist. Dann beträgt die Periodenlänge mindestens <math> p^n - 1 </math>. 
Der vorige Generator ergibt sich daraus mit <math> p = 2 </math> und <math> a_k \in \{ 0, 1 \} </math> als Sonderfall, und <math>n=1; \ p=m</math> liefert einen multiplikativen Kongruenzgenerator mit der Periodenlänge <math> p - 1 </math>.

Das Polynom <math> f(x) = x^n - \sum_{k=1}^{n} a_k x^{n-k} </math> ist ein ''primitives Polynom modulo <math>p</math>'', wenn die folgenden Bedingungen erfüllt sind:

(<math>\text{sei } r = \frac{p^n-1}{p-1} \text{ und } a = (-1)^{n-1} a_n </math>)

* <math> a </math> ist ein primitives Element modulo <math>p</math>
* das Polynom <math> x^r </math> ist kongruent zu <math> a </math> (modulo <math>f(x)</math>)
* für alle Primfaktoren <math>q</math> von <math>r</math> ist der Grad des Polynoms <math> x^{r/q} \bmod f(x) </math> positiv
Dabei wird Polynomarithmetik angewandt (siehe [[Polynom#Polynome in der abstrakten Algebra|Polynome]] sowie [[Polynomdivision]]), und mit den Koeffizienten wird modulo <math>p</math> gerechnet (sie sind Elemente des [[Restklassenring]]s <math> \Z / p \Z </math>).

== Siehe auch ==
* [[Liste von Zufallszahlengeneratoren]]

== Einzelnachweise ==
<references />

[[Kategorie:Pseudozufallszahlengenerator]]
[[Kategorie:Zahlentheorie]]

== Weblinks ==
* [https://www.staff.uni-mainz.de/pommeren/Kryptologie02/Bitstrom/Bitstrom.pdf Abhandlung über Bitstrom-Verschlüsselungen]

Kongruenzgenerator - Versionsgeschichte

imported>Bithisarea: /* growthexperiments-addlink-summary-summary:2|1|0 */