Zufälliges Fließkomma-Double im Inclusive-Bereich

First off, es gibt ein problem in Ihrem code: Versuchen randomInRange(0,5e-324) oder geben Sie einfach Math.random()*5e-324 in Ihrem browser die JavaScript-Konsole.

Sogar ohne überlauf/Unterlauf/denorms, ist es schwierig, Grund, zuverlässig zu floating point ops. Nach ein bisschen Graben, finde ich ein Gegenbeispiel:

>>> a=1.0
>>> b=2**-54
>>> rand=a-2*b
>>> a
1.0
>>> b
5.551115123125783e-17
>>> rand
0.9999999999999999
>>> (a-b)*rand+b
1.0

Ist es einfacher zu erklären, warum dies geschieht, mit a=2⁵³ und b=0,5: 2⁵³-1 ist die nächste Darstellbare Zahl nach unten. Die Standardeinstellung ("Runde auf die nächste gerade Zahl") Runde 2⁵³-0.5 (da 2⁵³ ist "noch" [LSB = 0] und 2⁵³-1 ist, "ungerade" [LSB = 1]), so subtrahieren Sie b bekommen und 2⁵³multiplizieren (2⁵³-1, und fügen Sie b 2⁵³ wieder.

Zur Beantwortung Ihrer zweiten Frage: Da die zugrunde liegende PRNG fast immer generiert eine zufällige Zahl im Intervall [0,2ⁿ-1], d.h. es erzeugt zufällige bits. Es ist sehr einfach wählen Sie einen geeigneten n (die bits, die Präzision in Ihre floating-point-Darstellung) und dividieren durch 2ⁿ und erhalten eine vorhersehbare Verteilung. Beachten Sie, dass einige zahlen in [0,1) dass Sie nie erzeugen mit dieser Methode (alles in (0,2^-53), mit IEEE-doubles).

Es bedeutet auch, dass Sie tun können a[Math.floor(Math.random()*a.length)] und sich keine sorgen über überlauf (Hausaufgaben: Im IEEE-Binär-Gleitkommazahl, die beweisen, dass b < 1 impliziert a*b < a für positive integer a).

Andere nette Sache ist, die man sich denken kann jedes zufällige Ausgabe x, stellvertretend für ein Intervall [x,x+2^-53) (die nicht-so-nette Sache ist, dass der Durchschnittliche Wert der zurückgegeben wird, etwas weniger als 0,5). Wenn man wieder in [0,1], tun Sie zurück, die Endpunkte mit der gleichen Wahrscheinlichkeit als alles andere, oder sollte Sie nur die Hälfte der Wahrscheinlichkeit, weil Sie nur für das halbe Intervall als alles andere?

Antwort auf die einfachere Frage der Rückgabe eine Zahl in [0,1], die Methode effektiv unten erzeugt eine ganze Zahl [0,2ⁿ] (durch generieren eine ganze Zahl in [0,2ⁿ⁺¹-1] und werfen es Weg, wenn es zu groß ist) und dividieren durch 2ⁿ:

function randominclusive() {
  //Generate a random "top bit". Is it set?
  while (Math.random() >= 0.5) {
    //Generate the rest of the random bits. Are they zero?
    //If so, then we've generated 2^n, and dividing by 2^n gives us 1.
    if (Math.random() == 0) { return 1.0; }
    //If not, generate a new random number.
  }
  //If the top bits are not set, just divide by 2^n.
  return Math.random();
}

Die Kommentare, die implizieren, base 2, aber ich denke die Annahmen sind also:

• 0 und 1 zurückgegeben werden soll equiprobably (d.h. das Math.random() nicht mit den engeren Abstand von floating-point-zahlen in der Nähe von 0).
• Math.random() >= 0.5 mit Wahrscheinlichkeit 1/2 (sollte true sein, auch für Basen)
• Die zugrunde liegenden PRNG ist gut genug, dass wir dies tun können.

Beachten Sie, dass die Zufallszahlen werden immer generiert, in Paaren: der eine in der while (a) ist immer gefolgt von entweder der einen in die if oder die am Ende (b). Es ist ziemlich einfach zu überprüfen, ist es sinnvoll, durch die Berücksichtigung eines PRNG, der gibt entweder 0 oder 0,5:

• a=0   b=0  : return 0
• a=0   b=0.5: return 0.5
• a=0.5 b=0  : 1 zurück
• a=0.5 b=0.5: loop

Probleme:

• Die Annahmen, die möglicherweise nicht wahr. Insbesondere ist ein gemeinsames PRNG ist, um die oberen 32 bit des 48-bit-LCG (Firefox und Java). Erzeugen Sie ein double-take 53 bits von zwei aufeinander folgenden Ausgängen und dividieren durch 2⁵³aber einige Ergebnisse sind unmöglich (man kann nicht generieren 2⁵³ - Ausgänge mit 48 bits der Staat!). Ich vermute, einige von Ihnen niemals 0 zurückgeben (vorausgesetzt, die single-threaded-Zugriff), aber ich fühle mich nicht wie das überprüfen der Java-Implementierung jetzt.
• Math.random() ist zweimal für jeden Potenzial Ausgabe als Konsequenz benötigen, um den zusätzlichen bit, aber dies stellt mehr Einschränkungen auf der PRNG (die wir auf Grund über vier aufeinander folgenden Ausgaben der oben genannten LCG).
• Math.random() wird aufgerufen durchschnittlich über vier mal pro Ausgabe. Ein bisschen langsam.
• Es wegwirft Ergebnisse deterministisch (vorausgesetzt, die single-threaded-Zugriff), so ist so ziemlich garantiert, um den Ausstoß verringern Raum.

InformationsquelleAutor der Antwort tc.

Wählen Sie einfach Ihre halb-offenen Intervall etwas größer, so dass, dass Ihre gewählte geschlossenes Intervall ist eine Teilmenge. Dann, halten Sie die Generierung der zufälligen variable, bis es landet, in der besagten geschlossenen Intervall.

Beispiel: Wenn du etwas möchtest, uniform in [3,8], dann immer wieder regenerieren, eine einheitliche Zufallsvariable in [3,9), bis es passiert, um land in [3,8].

function randomInRangeInclusive(min,max) {
 var ret;
 for (;;) {
  ret = min + ( Math.random() * (max-min) * 1.1 );
  if ( ret <= max ) { break; }
 }
 return ret;
}

Hinweis: Die Menge der Zeiten, die Sie erzeugen, der halb geöffneten R. V. ist die zufällige und potenziell unendlich, aber man kann sich damit die erwartete Anzahl der Anrufe, die anders als in der Nähe von 1, wie Sie möchten, und ich glaube nicht, dass es existiert eine Lösung, die keine potenziell rufen Sie unendlich viele Male.

InformationsquelleAutor der Antwort Berry

Was wäre eine situation, wo Sie BRAUCHEN würde, eine floating-point-Wert, inklusive der oberen Grenze? Für Ganzzahlen ich verstehen, aber für einen Schwimmer, den Unterschied zwischen inklusive und exklusive ist, was gefällt 1,0 e-32.

InformationsquelleAutor der Antwort Mike Schachter

Die Frage ist ähnlich zu Fragen, was ist der floating-point-Zahl direkt vor der 1.0? Es ist so ein floating point Zahl, aber es ist einer in 2^24 (IEEE float) oder eine in 2^53 (für eine double).

Der Unterschied ist in der Praxis vernachlässigbar.

InformationsquelleAutor der Antwort wallyk

private static double random(double min, double max) {
    final double r = Math.random();
    return (r >= 0.5d ? 1.5d - r : r) * (max - min) + min;
}

InformationsquelleAutor der Antwort ivan.a.bovin