Create Random Primes

  • C++

Es gibt 25 Antworten in diesem Thema. Der letzte Beitrag () ist von exc-jdbi.

    Hallo nafets

    Danke für deine Analyse. Hast dich da recht ins Zeug gelegt. Theoretisch wäre es möglich. Nur Praktisch kann es nie passieren das immer die gleiche Zufallszahl vom Generator erzeugt wird. Natürlich versteht sich von selber, dass min und max daher ein gewisses Delta haben müssen.

    Die Codes habe ich kurz umgeschrieben und das Mathe-Zeug rausgenommen. Ich werde zu einem späteren Zeitpunkt schauen was mathematisch optmiert werden kann. Auch die Eigenschaft mit der Suchrichtung werde ich später machen. Dafür habe ich angefangen einzelne Funktionen auf Generic umzubauen. Die Codes laufen so recht zügig. Siehe BIlder.


    Um Hinweise und Verbessung bin ich dankbar.


    Edit: Korrektur. Teils Sachen beibehalten, da Schlussendlich immer noch ein Fermattest

    Freundliche Grüsse

    exc-jdbi




    Hier der C#-Quellcode
    Spoiler anzeigen

    C#-Quellcode

    1. class Program
    2. {
    3. private static Random rnd;
    4. private double _maxf = 0.0;
    5. private double _minf = double.MaxValue;
    6. private ulong ggT(ulong a, ulong b)
    7. {
    8. ulong re = 0;
    9. while (b != 0)
    10. {
    11. re = a % b;
    12. a = b; b = re;
    13. }
    14. return a;
    15. }
    16. private bool isPrimePepin(ulong p)
    17. {
    18. //Pépin-Test folgert aus Lucas-Test (sehr sicher)
    19. ulong k = 0;ulong l = 0;ulong o = 0;
    20. k = 2;//pow(2,m)%m = immer 2
    21. l = (ulong)(BigInteger.ModPow(2, k, p)) + 1uL;
    22. k = (l - 1uL) >> 1;
    23. o = (ulong)(BigInteger.ModPow(3, k, l));
    24. if (o == l - 1)
    25. {
    26. return true;
    27. }
    28. return false;
    29. }
    30. private bool isPrimeFermat(ulong n, ulong t)
    31. {
    32. ulong[] a = { 2, 3, 5, 7, 11, 13, 17, 19, 23 };
    33. for (int i = 0; i < 9; i++)
    34. {
    35. if (n == a[i]) return true;
    36. if (n % a[i] == 0) return false;
    37. }
    38. ulong j = 1; ulong res = 0;
    39. for (ulong i = 0; i < t; i++)
    40. {
    41. j++;
    42. while (j < n)
    43. {
    44. if (ggT(j, n) == 1)
    45. {
    46. break;
    47. }
    48. j++;
    49. }
    50. res = (ulong)(BigInteger.ModPow(j, n - 1uL, n));
    51. if (res == 1)
    52. {
    53. return isPrimePepin(n);
    54. }
    55. }
    56. return false;
    57. }
    58. private double nextRnd()
    59. {
    60. double tmp = (double)((double)rnd.Next(int.MaxValue) * (double)(1.0 / (double)(int.MaxValue)));
    61. if (tmp < _minf) _minf = tmp;
    62. if (tmp > _maxf) _maxf = tmp;
    63. if (_maxf - _minf == 0.0)
    64. {
    65. nextRnd();
    66. }
    67. return 1.0 - ((_maxf - tmp) / (_maxf - _minf));
    68. }
    69. private ulong uniformDistribution(ulong min, ulong max)
    70. {
    71. ulong res = 0; double n = 0; double r = 0; double t = 0;
    72. n = (double)(max - min); r = nextRnd(); t = r * n;
    73. ulong b = max - min;
    74. if (t >= b) {
    75. res = max;
    76. } else {
    77. res = min + (ulong)(t > b ? b : t);
    78. }
    79. return res;
    80. }
    81. private ulong genRndUlong(ulong min, ulong max)
    82. {
    83. return (ulong)(uniformDistribution(min, max));
    84. }
    85. private ulong findPrimeFermat(ulong min, ulong max, ulong t)
    86. {
    87. ulong res = 0;
    88. ulong num = 0; int cnt = 0; int ii = 100000;
    89. while (true)
    90. {
    91. if (cnt++ >= ii) break;
    92. num = genRndUlong(min, max);
    93. if ((num == 0) || (num == 1))
    94. continue;
    95. if (num % 2 == 0)
    96. num |= 1;
    97. if (isPrimeFermat(num, t))
    98. {
    99. return num;
    100. }
    101. }
    102. if (cnt >= 100000)
    103. {
    104. msgError(0);
    105. }
    106. return res;
    107. }
    108. private void msgError(int eN)
    109. {
    110. switch (eN)
    111. {
    112. case 0: throw new Exception("Could not generate a random prime. Check intervall {min,max}");
    113. }
    114. }
    115. static void Main(string[] args)
    116. {
    117. rnd = new Random();
    118. int maxCnt = 1000;
    119. //ulong min = 0; ulong max = 255; ulong trial = 3;
    120. ulong min = 1000000000000000000; ulong max = ulong.MaxValue; ulong trial = 3;
    121. ulong[] prime = new ulong[maxCnt];
    122. Stopwatch sw = new Stopwatch();
    123. sw.Start();
    124. Program p = new Program();
    125. for (int i = 0; i < maxCnt; i++)
    126. {
    127. prime[i] = p.findPrimeFermat(min, max, trial);
    128. }
    129. int EndZeit = sw.Elapsed.Milliseconds;
    130. for (int i = 0; i < maxCnt; i++)
    131. {
    132. if (prime[i] > 0)
    133. {
    134. Console.WriteLine(prime[i].ToString());
    135. }
    136. }
    137. Console.WriteLine();
    138. Console.WriteLine("Primes:\t\t" + maxCnt + " pcs.");
    139. Console.WriteLine("Times:\t\t" + EndZeit + " ms");
    140. Console.ReadKey();
    141. }
    142. }




    Und hier der VB.NET-Quellcode
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Imports System.Numerics
    4. Imports System.Runtime.CompilerServices
    5. Module findPrimeFermat
    6. Private rnd As Random
    7. Private _minf As Double = Double.MaxValue, _maxf As Double = 0.0
    8. Private Function ggT(ByVal a As ULong, ByVal b As ULong) As ULong
    9. Dim re As ULong = 0
    10. While Not b = 0
    11. re = a Mod b : a = b : b = re
    12. End While
    13. Return a
    14. End Function
    15. Private Function isPrimePepin(ByVal p As ULong) As Boolean
    16. Dim k As ULong, l As ULong, o As ULong
    17. isPrimePepin = False
    18. 'Pépin-Test folgert aus Lucas-Test (sehr sicher)
    19. k = 2 'pow(2,m)%m = immer 2
    20. l = CULng(BigInteger.ModPow(2, k, p)) + 1UL
    21. k = (l - 1UL) >> 1 ' = (l-1)/2
    22. o = CULng(BigInteger.ModPow(3, k, l))
    23. If o = l - 1 Then
    24. Return True
    25. End If
    26. End Function
    27. Private Function isPrimeFermat(ByVal n As ULong, ByVal t As ULong) As Boolean
    28. Dim a As ULong() = {2, 3, 5, 7, 11, 13, 17, 19, 23}
    29. For i As Integer = 0 To 8
    30. If n = a(i) Then Return True
    31. If n Mod a(i) = 0 Then Return False
    32. Next
    33. Dim j As ULong = 1, res As ULong = 0
    34. For i As ULong = 0 To t - 1UL
    35. j += 1UL
    36. While j < n
    37. If ggT(j, n) = 1 Then
    38. Exit While
    39. End If
    40. j += 1UL
    41. End While
    42. res = CULng(BigInteger.ModPow(j, n - 1UL, n))
    43. If res = 1 Then
    44. Return isPrimePepin(n)
    45. End If
    46. Next
    47. Return False
    48. End Function
    49. Private Function nextRnd() As Double
    50. Dim tmp As Double = CDbl(CDbl(rnd.Next()) * CDbl(1.0 / CDbl(Integer.MaxValue)))
    51. If tmp < _minf Then _minf = tmp
    52. If tmp > _maxf Then _maxf = tmp
    53. If _maxf - _minf = 0.0 Then
    54. nextRnd()
    55. End If
    56. Return 1.0 - ((_maxf - tmp) / (_maxf - _minf))
    57. End Function
    58. Private Function uniformDistribution(ByVal min As ULong, ByVal max As ULong) As ULong
    59. Dim res As ULong = 0, n As Double, r As Double, t As Double
    60. n = CDbl(max - min) : r = nextRnd() : t = r * n
    61. Dim b As ULong = max - min
    62. If t >= b Then
    63. res = max
    64. Else : res = min + CULng(If(t > b, b, t))
    65. End If
    66. Return res
    67. End Function
    68. Private Function genRndUlong(ByVal min As ULong, ByVal max As ULong) As ULong
    69. Return CULng(uniformDistribution(min, max))
    70. End Function
    71. Private Function findPrimeFermat(ByVal min As ULong, ByVal max As ULong, ByVal t As ULong) As ULong
    72. findPrimeFermat = 0UL
    73. Dim num As ULong = 0, cnt As Integer = 0, ii As Integer = 100000
    74. While True
    75. cnt += 1 : If cnt = ii Then Exit While
    76. num = genRndUlong(min, max)
    77. If (num = 0) OrElse (num = 1) Then Continue While
    78. If num Mod 2 = 0 Then num -= 1UL
    79. If isPrimeFermat(num, t) Then
    80. Return num
    81. End If
    82. End While
    83. If cnt = 100000 Then
    84. msgError(0)
    85. End If
    86. End Function
    87. Private Sub msgError(ByVal eN As Integer)
    88. Select Case eN
    89. Case 0 : Throw New Exception("Could not generate a random prime. Check intervall {min,max}")
    90. End Select
    91. End Sub
    92. Public Sub Main()
    93. rnd = New Random()
    94. Dim maxCnt As Integer = 1000
    95. 'Dim min As ULong = 0 : Dim max As ULong = 256 : Dim trial As ULong = 3
    96. Dim min As ULong = CULng(10 ^ 18) : Dim max As ULong = ULong.MaxValue : Dim trial As ULong = 3
    97. Dim prime As ULong() = New ULong(maxCnt - 1) {}
    98. Dim sw As New Stopwatch()
    99. sw.Start()
    100. For i As Integer = 0 To maxCnt - 1
    101. prime(i) = findPrimeFermat(min, max, trial)
    102. Next
    103. Dim EndZeit As Integer = sw.Elapsed.Milliseconds
    104. For i As Integer = 0 To maxCnt - 1
    105. If prime(i) > 0 Then
    106. Console.WriteLine(prime(i).ToString())
    107. End If
    108. Next
    109. Console.WriteLine()
    110. Console.WriteLine("Primes:" & vbTab & vbTab & maxCnt & " pcs.")
    111. Console.WriteLine("Times:" & vbTab & vbTab & EndZeit & " ms")
    112. Console.ReadKey()
    113. End Sub
    114. End Module

    Dieser Beitrag wurde bereits 9 mal editiert, zuletzt von „exc-jdbi“ ()

    Das mit der Analyse ist kein Problem für mich - mich interessiert dieses Thema mindestens genauso viel wie dich (ich würde fast sagen, dass ich solche Optimierungsaufgaben liebe) ;)
    Und auch wenn der Fall der immer wieder generierten Nicht-Primzahlen äußerst unwahrscheinlich ist, ist es trotzdem ein Faktor, welcher die Laufzeit sicherlich negativ beeinflusst. Man müsste jedoch einfach mal praktisch überprüfen, wie oft unsere Versionen pro generierter Primzahl Nicht-Primzahlen ausprobieren. Was mich auch noch nicht überzeugt hat, ist der Fermatsche Primzahltest: Ich bin mir zwar nicht sicher, vermute jedoch sehr stark, dass noch es Zahlen gibt, welche durch deinen Check durchkommen, obwohl sie keine Primzahlen sind. Nichtsdestotrotz finde ich deine Ergebnisse ziemlich gut :thumbup:

    Der Code sieht eigentlich auch ganz gut aus, mir sind jedoch ein paar Sachen aufgefallen (das meiste ist jedoch Kleinkram ^^):
    Zeile 14 (ulong a = aa, b = bb, rem = 0;): Die Variablen a und b sind unnötig - du kannst auch direkt aa und bb für die Berechnung verwenden, da die Werte ja "By Value" übergeben werden.
    Zeile 22 (ulong[] a = { 2, 3, 5, 7, 11, 13, 17, 19, 23 };): Es ist nicht nötig, die 2 als Faktor zu überprüfen, da du ja nur ungerade Zahlen in die Funktion reingibst. Wenn du die Funktion doch allgemeingültig machen wolltest, solltest du die Prüfung vom Primfaktor 2 zugunsten besserer Performance anders gestalten ((n & 1) == 1) und auch Zahlen wie 1 separat behandeln.
    Zeile 25 (if (n == a[i]) return true;): Dieser Check ist eigentlich mMn ebenfalls aus dem vorher genannzen Grund unnötig.
    Zeile 48 (num = Convert.ToUInt64(num << 33);): Ist der Shift um 33 Bits hier absichtlich? Müssten es nicht 32 sein? Generell generierst du aber auch nur eine 32-Bit-Zufallszahl - wo kommen denn die anderen 32 Bit her?
    Zeile 49 (num = (num % ((max + 1) - min)) + min;): Das Begrenzen des Zufallszahlenbereiches durch Wrappen per Modulo-Operation erzeugt oft einen Bias - kleinere Zufallszahlen werden tendentiell bevorzugt. Ich habe meine Version zwar nicht genau überprüft, jedoch erzeugt diese eigentlich sehr gleichmäßig verteilte Zufallszahlen, was bei deiner Version leider nicht garantiert ist.
    Zeile 50 (if (!((num & 1) == 1)) num -= 1;): Ein einfaches num |= 1 erreicht exakt das gleiche und ist simpler.
    Zeile 53 (}return 0;): Das Werfen einer Exception (bspw. throw new Exception("Could not generate a random prime.") oä) fände ich hier sinnvoller - eine Exception ist eigentlich immer besser als einen eigentlich nicht im erwarteten Intervall liegenden Wert zurückzugeben.
    Zeile 59 (ulong min = 1000000000000000000; ulong max = ulong.MaxValue; ulong trial = 3;): Warum änderst du hier plötzlich das Intervall, welches wir vorher genutzt haben? Außerdem entsteht durch das Verwenden von ulong.MaxValue in Zeile 49 ein Overflow, da ulong.MaxValue + 1 = 0. Dieses Vorgehen sorgt in C# auch standardmäßig für keine Exception - durch das Verwenden eines checked-Blockes könntest du dieses Problem verhindern - da würde dann eine dementsprechende Exception geworfen.
    Zeile 63 (System.DateTime StartZeit = System.DateTime.Now;): Anstatt die Laufzeit über die Systemuhr zu messen, würde ich eine Stopwatch verwenden.
    Super danke nafets für die wertvollen Tips, werde ich noch anpassen.

    Was mir gerade aufgefallen ist:
    Zu Zeile 22, werde ich anschauen und auch die Zahlen 0 + 1 beachten
    Zu Zeile 48, sollte stimmen da int.maxvalue == 2147483647 == (2^31)-1 entspricht und somit 31 + 33 = 64 -> 2^64 Werde ich nochmals anschauen.
    Zu Zeile 49, da kann ich dir nur recht gebe. Die Verteilung ist wirklich nicht gut. Ich könnte eine Funktion einbauen.
    Ich denke so etwas könnte noch eine Möglichkeit sein. Muss ich aber anschauen

    Quellcode

    1. z=Zufallszahl
    2. func gleichverteilung(min,max)
    3. n=max-min+1 (so sollte kein problem sein)
    4. Return (min+floor(z)*n)


    Zeile 59 ? Das ist ja die Main, von da aus kommt die Definition.

    Die anderen Punkte werde ich nächste Wochen wenn ich Zeit finde in meinem obigen Code ändern.

    Freundliche Grüsse

    exc-jdbi

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ ()

    exc-jdbi schrieb:

    Zu Zeile 48, sollte stimmen da int.maxvalue == 2147483647 == (2^31)-1 entspricht und somit 31 + 33 = 64 -> 2^64 Werde ich nochmals anschauen.

    Stimmt - du kriegst nur 31 zufällige Bits.

    exc-jdbi schrieb:

    Zu Zeile 49, da kann ich dir nur recht gebe. Die Verteilung ist wirklich nicht gut. Ich könnte eine Funktion einbauen.
    Ich denke so etwas könnte noch eine Möglichkeit sein. Muss ich aber anschauen

    Das Problem ist, dass du versuchst, aus 31 zufälligen Bits eine zufällige 64-Bit-Zahl zu konstruieren - das ist nicht möglich. Stattdessen solltest du die ​Random.NextBytes()-Funktion oder einen anderen Algorithmus (-> MersenneTwister?) nutzen. Genau das ist übrigens auch der Grund, warum ich einerseits extra den MersenneTwister-Algo für die Zufallszahlengeneration genutzt habe und meine spezielle Funktion geschrieben habe. Ich würde dir übrigens gerne die Nutzung meiner Funktion anstatt deiner Variante nahelegen, da beide von deinen Versionen soweit ich das beurteilen kann keine wirklich zufälligen Zahlen im spezifizierten Intervall produzieren.
    Für die echten Zufallszahlen bin ich an einem eigenem BBS. Mit dem erzeuge ich dann cryptographisch sichere Zufallszahlen.
    Für den normalen Gebrauch werde ich den MT nehmen. (Oder den Xorshift den finde ich auch noch gut, nur da müsste ich noch die Gleichverteilung entsprechen präzisieren. Vorteil unglaublich schnell.)

    Quellcode

    1. Blum-Blum-Shub-Generator
    2. + n sollte hinreichend groß sein; für kryptografische Anwendung mindestens etwa 200 Dezimalstellen.
    3. + p und q sollten etwa gleichdimensioniert sein, aber nicht zu nah beieinander liegen, etwa 2 < p/q < 1000.
    4. + p - 1 und p + 1 sowie q - 1 und q + 1 sollten jeweils einen großen Primfaktor haben, größer als ca n^(1/4).

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „exc-jdbi“ ()

    Modifizierter XorShift für VB.Net

    Hallo Communit

    Hier noch ein modifizierter XorShift-Randomgenerator speziell für Vb.Net, den ich mal gemacht habe. Die Verteilung für kleine Zahlen könnte man sicher noch besser machen. So wie es jedoch ist, würde ich behaupten dass der Generator sehr zufällig ist, leider auf lasten der Performence. Vielleicht hat jemand von euch Lust einen DieHard-Test oder ähnliches zu machen.

    Freundliche Grüsse

    exc-jdbi

    Edit: Noch eine kleine Erklärung warum ich das so gemacht habe
    Beim XorShift Generator geht es darum nebst dem Startwert auch den kontinuierlichen Ablauf des Zykluses massiv zu stören.
    Darum auch die warmUp-Phase. Diese dient auch dazu, eine bessere Verteilung zu bewirken.
    Hat man den Ablauf massiv gestört, kann eine Analyse des Generators nur noch aus dem "inneren Zustand"
    gemacht werden. Da aber der Ablauf keiner linearen Struktur verlauft, Wird das extrem schwierig.


    de.wikipedia.org/wiki/Xorshift
    www.jstatsoft.org/v08/i14/paper

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Module ModXorShiftVb
    4. Sub Main()
    5. Dim pcs As Integer = 1000
    6. Dim xos As New XorShiftVB
    7. Dim max = ULong.MaxValue
    8. Dim min As ULong = CULng(10 ^ 18)
    9. Dim sw As New Stopwatch()
    10. sw.Start()
    11. If xos.interval(min, max) Then
    12. 'If xos.interval(0, 255) Then
    13. For i As Integer = 0 To pcs - 1
    14. Console.WriteLine(xos.rnd()) ' rnd(true or false)
    15. Next
    16. End If
    17. printTime(sw.Elapsed, pcs)
    18. Console.ReadLine()
    19. End Sub
    20. Private Sub printTime(ByVal ts As TimeSpan, ByVal n As Integer)
    21. Dim elapsedTime As String = String.Format("{0:00}:{1:00}:{2:00}.{3:000}", _
    22. ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds)
    23. Console.WriteLine()
    24. Console.WriteLine("Randoms:" & vbTab & n.ToString & " pcs")
    25. Console.WriteLine("RunTime: " & vbTab & elapsedTime.ToString)
    26. End Sub
    27. End Module
    28. Public Class XorShiftVB
    29. Private g As Generator
    30. Private _min As ULong, _max As ULong
    31. Private _minf As Double = Double.MaxValue, _maxf As Double = 0.0
    32. Public ReadOnly Property rnd(Optional ByVal _norm As Boolean = False) As ULong
    33. Get
    34. Return genRndUlong(_norm)
    35. End Get
    36. End Property
    37. Public ReadOnly Property interval(ByVal min As ULong, ByVal max As ULong) As Boolean
    38. Get
    39. Return setInterval(min, max)
    40. End Get
    41. End Property
    42. Private Function setInterval(ByVal min As ULong, ByVal max As ULong) As Boolean
    43. setInterval = False
    44. If min < max Then
    45. Me._min = min : Me._max = max
    46. Return True
    47. End If
    48. End Function
    49. Private Function genRndUlong(Optional ByVal _norm As Boolean = False) As ULong
    50. If _norm Then
    51. Return CULng(normDistribution())
    52. End If
    53. Return uniformDistribution()
    54. End Function
    55. Private Function normDistribution() As ULong
    56. Dim n As Integer = 6, sum As Double = 0
    57. For i As Integer = 0 To n - 1
    58. sum = (sum + uniformDistribution())
    59. Next
    60. sum /= 6.0
    61. Return CULng(sum)
    62. End Function
    63. Private Function uniformDistribution() As ULong
    64. Dim res As ULong = 0, n As Double, r As Double, t As Double
    65. n = CDbl(_max - _min) : r = nextRnd() : t = r * n
    66. Dim b As ULong = _max - _min
    67. If t >= b Then
    68. res = _max
    69. Else : res = _min + CULng(If(t > b, b, t))
    70. End If
    71. Return res
    72. End Function
    73. Private Function nextRnd() As Double
    74. Dim tmp As Double = CDbl(CDbl(g.getRnd) * CDbl(1.0 / CDbl(ULong.MaxValue)))
    75. If tmp < _minf Then _minf = tmp
    76. If tmp > _maxf Then _maxf = tmp
    77. If _maxf - _minf = 0.0 Then
    78. nextRnd()
    79. End If
    80. Return 1.0 - ((_maxf - tmp) / (_maxf - _minf))
    81. End Function
    82. <System.Diagnostics.DebuggerStepThrough()> _
    83. Private Class Generator
    84. Const n As Integer = 10
    85. Private Shared w As ULong = 88675123, v As ULong = 5783321, d As ULong = 6615241
    86. Private Shared x As ULong = 123456789, y As ULong = 362436069, z As ULong = 521288629
    87. Friend ReadOnly Property getRnd() As ULong
    88. Get
    89. Return createRnd()
    90. End Get
    91. End Property
    92. <System.Diagnostics.DebuggerHidden()> _
    93. Friend Function addMod(ByVal a As ULong, ByVal b As ULong, ByVal m As ULong) As ULong
    94. Dim res As Double = 0.0, aa As Double = a, bb As Double = b, mm As Double = m
    95. aa /= mm : bb /= mm
    96. res = ((aa + bb) - Math.Truncate(aa + bb)) * mm
    97. Return CULng(res)
    98. End Function
    99. <System.Diagnostics.DebuggerHidden()> _
    100. Private Function createRnd() As ULong
    101. Dim rX As ULong = 0
    102. Dim r As Integer = CInt(xos192() Mod n) + 1
    103. For i As Integer = 0 To r - 1
    104. rX = xos192()
    105. Next
    106. Dim x As Integer = 0
    107. Dim base As ULong = 10
    108. Dim rY As ULong, sum As ULong
    109. For i As Integer = 0 To r - 1
    110. x = CInt((rX / (base ^ i)) Mod base) + 1
    111. For j As Integer = 0 To x - 1
    112. rY = CULng(xos192() / r)
    113. Next
    114. sum += rY
    115. Next
    116. Return sum
    117. End Function
    118. <System.Diagnostics.DebuggerHidden()> _
    119. Private Function xos192() As ULong
    120. Dim t As ULong = (x Xor (x >> 2))
    121. x = y : y = z : z = w : w = v
    122. v = (v Xor (v << 4)) Xor (t Xor (t << 1))
    123. d = addMod(d, 362437, ULong.MaxValue)
    124. Return addMod(d, v, ULong.MaxValue)
    125. End Function
    126. <System.Diagnostics.DebuggerHidden()> _
    127. Private Sub warmUp()
    128. Dim rnd As New Random
    129. Dim cnd As Integer = 1000000
    130. cnd = rnd.Next(10000, cnd)
    131. For i As Integer = 0 To cnd
    132. xos192()
    133. Next
    134. End Sub
    135. <System.Diagnostics.DebuggerHidden()> _
    136. Public Sub New()
    137. warmUp()
    138. End Sub
    139. End Class
    140. <System.Diagnostics.DebuggerHidden()> _
    141. Public Sub New()
    142. g = New Generator
    143. Me._min = 0 : Me._max = 100
    144. Dim s = genRndUlong()
    145. For i As Integer = 0 To 100
    146. s = genRndUlong()
    147. Next
    148. End Sub
    149. End Class

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „exc-jdbi“ ()