Schreiben Sie eine wahrhaft inklusive random-Methode für javascript

Javascript-MATH-Objekt hat eine zufällige Methode, die zurückgibt, aus der Menge [0,1) 0-inclusive, 1 exklusive. Gibt es einen Weg, um wieder einen wirklich zufälligen Methode, die beinhaltet 1.

z.B.

var rand = MATH.random()*2;

if(rand > 1)
{
   rand = MATH.floor(rand);
}

return rand;

Während dieses gibt immer eine Zahl aus der Menge [0,1] es ist nicht wirklich zufällig.

definieren zufällig 🙂
Ich Frage mich, was die Verwendung von insbesondere 1?
Es ist zufällig, nur eben nicht einheitlich zufällig.
Entschuldigung, ich meine einheitlich zufällig.
soweit die Anwendung dieses, nur neugierig 🙂

InformationsquelleAutor Adrian Adkison | 2010-01-27

8

Ob es inclusive der Grenzen sollte keine Rolle spielen; in der Tat, streng genommen, was Sie zu tun versuchen, nicht wirklich sinnvoll. Denken Sie daran, dass unter einer kontinuierlichen Wahrscheinlichkeitsverteilung, ist die Wahrscheinlichkeit, einen bestimmten Wert, ist verschwindend gering sowieso, also mathematisch sprechend, werden Sie nie sehen, den genauen Wert der 1.

Natürlich, in der Welt der Computer, dem Sie die Verteilung der RNG ist nicht wirklich kontinuierlich, so ist es "möglich", auf die Sie stoßen einen bestimmten Wert (was auch immer das bedeutet), sondern die Tatsache, dass Sie sich auf eine Einschränkung, wie die real-zahlen gespeichert sind Hinweise auf Probleme mit Ihrem Ansatz, zu welchem problem Sie versuchen zu lösen.
- Vielen Dank für Ihre Antwort. Ich denke, es ist nur ein schlecht gebildet übung, die ich mache. Die übung eigene zu schreiben, Math-Objekt mit einer zufälligen Methode, dauert min,max und integratives als Argumente. Die inclusive-argument ist ein boolescher Wert, der sagt, ob das set, das inklusive oder exklusive. Nun, wie ich schon in meiner ersten Frage, die die Mathematik.random () - Funktion ist weder integrativ oder ausgrenzend, weil es inludes 0 schließt aber 1. So schreiben Sie eine zufällige Methode, die wirklich inklusive oder exklusive und gleichmäßig verteilt ist nicht möglich, richtig?
- Es ist nicht unmöglich, denn es gibt eigentlich nur eine endliche Anzahl von Werten, die erzeugt werden können, die von der RNG zwischen 0 und 1 (eher als ein Kontinuum). Es ist aber mathematisch unsinnig, so zu tun. Entweder die übung bezieht sich insbesondere auf ganze zahlen, oder es ist eine schlechte Frage. Darüber hinaus erweitern eine diskrete Gleichverteilung eine weitere gleichmäßige Verteilung ist nicht trivial. Trevor und Brian McKenna ' s Lösungen sind sehr nah, aber nicht perfekt gleichmäßig.
InformationsquelleAutor Will Vousden
14

Zurückkehren [0,1] inklusive:
```
if(MATH.random() == 0)
    return 1;
else
    return MATH.random();
```
Erklärung: Wenn der erste Aufruf der Funktion random() liefert 0, 1 zurück. Ansonsten rufen Sie random erneut, die [0,1). Daher wird es wieder [0,1] all inclusive.
- warum random zweimal. was, wenn Sie bekommen immer noch eine 0 ...
- Dies umfasst nicht 0, entweder, wie Sie erwähnen in Ihrem Kommentar zu nickf
- Wenn der erste random () - Aufruf ist nicht 0, das zweite die random () - Aufruf sein könnte.
- Ich denke, es ist schwer zu sagen einheitlich, aber +1 für bringen 1 zurück.
- Dies ist nicht ganz einheitlich, aber es ist sehr nahe.
- Dies bedeutet, im Gesicht, sind 0.
- ja verstanden hab ich es von Trevor follow-up-Kommentar. Dank
InformationsquelleAutor Trevor
7

Den Math.random - Funktion gibt eine Zufallszahl zwischen 0 und 1, wobei 0 ist inclusive und 1 exklusive. Dies bedeutet, dass der einzige Weg, um richtig verteilen die Zufallszahlen als Ganzzahlen im Intervall ist eine exklusive Obere Grenze.

Anzugeben inclusive die Obere Grenze, die Sie gerade hinzufügen, um es, um es exklusiv in der Berechnung. Diese verteilen die Zufallszahlen korrekt zwischen 7 und 12 inklusive:
```
var min = 7;
var max = 12;
var rnd = min + Math.floor(Math.random() * (max - min + 1));
```
- +1 Für den klassischen Ansatz zur Definition einer beliebigen zufälligen Auswahl
InformationsquelleAutor Guffa
3

Du willst auch 1?
```
return 1 - Math.random();
```
Aber ich denke, das ist eine jener Fragen, die Hinweise auf andere Probleme. Warum müssen Sie 1? Wahrscheinlich gibt es ein besserer Weg, es zu tun.
- Aber es wird nicht zählen 0
- das wäre 0 exklusive jetzt .. wäre es nicht ?
- Ja, aber er hat nicht gesagt, dass außer der 0 ein problem war nur, dass außer 1 war.
InformationsquelleAutor nickf
2

Von dem, was ich sehen kann, aus der JavaScript-Konsole in Chrome Math.random() erzeugt eine Zahl von 0 bis 0.9999999999999999. Unter Berücksichtigung dieser Tatsache, können Sie bekommen, was Sie wollen, durch hinzufügen eines Modifikators. Zum Beispiel, hier ist eine Funktion, die Ihnen quasi-random-float zwischen 0 und 1, wobei 1 inklusive:
```
function randFloat() {
  //Assume random() returns 0 up to 0.9999999999999999
  return Math.random()*(1+2.5e-16);
}
```
Können Sie versuchen, diese in der Konsole eingeben 0.9999999999999999*(1+2.5e-16) -- wird es wieder genau 1. Sie können diese weiter und liefert ein float zwischen 0 und 1024 (inklusive) mit dieser Funktion:
```
function randFloat(nMax) {
  //Assume random() returns 0 up to 0.9999999999999999
  //nMax should be a float in the range 1-1024
  var nMod;
  if (nMax<4) nMod = 2.5e-16;
  else if (nMax<16) nMod = 1e-15;
  else if (nMax<32) nMod = 3.5e-15;
  else if (nMax<128) nMod = 1e-14;
  else if (nMax<512) nMod = 3.5e-14;
  else if (nMax<1024) nMod = 1e-13;
  return Math.random()*(nMax+nMod);
}
```
Wahrscheinlich gibt es einen effizienteren Algorithmus zu haben irgendwo.

InformationsquelleAutor thdoan
1

Da diese Frage wurde noch mal gefragt, und ich wusste nicht, Lesen Sie diesen Ansatz hier werde ich hinzufügen, eine andere Antwort.

IMO das beste, was Sie tun können, ohne zu viel Aufwand wäre:

exklusiv:
```
//simply ignore the 0
for(var rand=0; !rand;rand = Math.random());

//or simpler:
var rand = Math.random() || Math.random();
//because the probability for two consecutive `0` is pretty much non existant.
```
diese gar nicht einzuführen, ist ein Fehler, da wir gerade ausgeschlossen, die Möglichkeit der Rückkehr 0 jeder andere Wert zwischen 0 und 1 die gleiche Wahrscheinlichkeit

inclusive:
```
var rand = Math.random() * 2;
if(rand > 1) rand-=1;
//so the 0 shares it's probability with the 1.
```
nur darüber im klaren sein, wie winzig der "Fehler" ist:
- die Wahrscheinlichkeit für eine 0 oder eine 1 ist
  
  1 /Math.pow(2, 54) oder über 5.55e-17
- die Wahrscheinlichkeit für einen beliebigen anderen Wert zwischen 0 und 1 ist
  
  1 /Math.pow(2, 53) oder über 11.1e-17
und das ganze random-Funktion wäre:
```
function random(min, max, inclusive){
    var r = Math.random();
    if(inclusive)
        r = r>0.5? 2*r-1: 2*r;
    else 
        while(!r) r = Math.random();

    return r * (max - min) + min;
}
```
Edit: ich bin mir nicht sicher, ob ich nicht einen Fehler machen, aber sollte dann nicht die Wahrscheinlichkeit behoben werden, die auf den integrativen Ansatz, wenn ich ein bisschen um die Nullen und Einsen, und daher doppelte Ihrer Wahrscheinlichkeit:
```
var rand = Math.random() * 4;
rand = (rand % 1) || (rand & 1);
```
InformationsquelleAutor Thomas

Nachtrag:

Sich ein Blick auf die java.util.Random source-code enthalten mit dem Vertrieb von Oracle JDK 7 ("Copyright (c) 1995, 2010, Oracle und/oder seinen verbundenen Unternehmen. Alle Rechte vorbehalten. ORACLE-PROPRIETARY/CONFIDENTIAL. Die Nutzung unterliegt der Lizenzvereinbarung") zeigt diesen einfachen code:

class Random {

    public float nextFloat() {
        return next(24) / ((float)(1 << 24));
    }

    protected int next(int bits) {
        long oldseed, nextseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            nextseed = (oldseed * multiplier + addend) & mask;
        } while (!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> (48 - bits));
    }
}

So, für nextFloat():

Nehme ein "random integer-Wert" zwischen 0 und 2^24-1 (oder eher ein zufälliger 24-bit bitpattern interpretiert als integer-Wert),
Konvertieren float (in Java, "float" wird beauftragt, eine IEEE-724 32-bit floating point, die machen bis zu 2^24 ohne Verlust von Genauigkeit, und dies wird somit ein Wert zwischen 0 und 1.6777215E7)
Dann teilen Sie diese durch die float-Darstellung von 2^24, wieder nur darstellbar, ohne Verlust der Genauigkeit als 1.6777216E7. 2^24+1 = 16777217 würde drop-down-1.6777216E7, wenn Sie gezwungen werden, zu schweben. In dem code, das sollte eigentlich konstant sein. Hey Sonne, Zyklen wachsen nicht auf Bäumen!!
Division in float in [0.0 .. 0.99999994] (die korrekte division Ergebnis wäre um 0.999999940395355224609375), denke ich, alle möglichen IEEE 724 Gleitkommazahlen zwischen 'gleich möglich'.

Siehe auch IEEE floating point und Floating-Point-Arithmetik auf der JVM.

In der Javadoc-Kommentare für " next() ist:

/**
 * Generates the next pseudorandom number. Subclasses should
 * override this, as this is used by all other methods.
 *
 * <p>The general contract of {@code next} is that it returns an
 * {@code int} value and if the argument {@code bits} is between
 * {@code 1} and {@code 32} (inclusive), then that many low-order
 * bits of the returned value will be (approximately) independently
 * chosen bit values, each of which is (approximately) equally
 * likely to be {@code 0} or {@code 1}. The method {@code next} is
 * implemented by class {@code Random} by atomically updating the seed to
 *  <pre>{@code (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)}</pre>
 * and returning
 *  <pre>{@code (int)(seed >>> (48 - bits))}.</pre>
 *
 * This is a linear congruential pseudorandom number generator, as
 * defined by D. H. Lehmer and described by Donald E. Knuth in
 * <i>The Art of Computer Programming,</i> Volume 3:
 * <i>Seminumerical Algorithms</i>, section 3.2.1.
 *
 * @param  bits random bits
 * @return the next pseudorandom value from this random number
 *         generator's sequence
 * @since  1.1
 */

In der Javadoc-Kommentare für nextFloat() ist:

/**
 * Returns the next pseudorandom, uniformly distributed {@code float}
 * value between {@code 0.0} and {@code 1.0} from this random
 * number generator's sequence.
 *
 * <p>The general contract of {@code nextFloat} is that one
 * {@code float} value, chosen (approximately) uniformly from the
 * range {@code 0.0f} (inclusive) to {@code 1.0f} (exclusive), is
 * pseudorandomly generated and returned. All 2<font
 * size="-1"><sup>24</sup></font> possible {@code float} values
 * of the form <i>m&nbsp;x&nbsp</i>2<font
 * size="-1"><sup>-24</sup></font>, where <i>m</i> is a positive
 * integer less than 2<font size="-1"><sup>24</sup> </font>, are
 * produced with (approximately) equal probability.
 *
 * <p>The method {@code nextFloat} is implemented by class {@code Random}
 * as if by:
 *  <pre> {@code
 * public float nextFloat() {
 *   return next(24) /((float)(1 << 24));
 * }}</pre>
 *
 * <p>The hedge "approximately" is used in the foregoing description only
 * because the next method is only approximately an unbiased source of
 * independently chosen bits. If it were a perfect source of randomly
 * chosen bits, then the algorithm shown would choose {@code float}
 * values from the stated range with perfect uniformity.<p>
 * [In early versions of Java, the result was incorrectly calculated as:
 *  <pre> {@code
 *   return next(30) /((float)(1 << 30));}</pre>
 * This might seem to be equivalent, if not better, but in fact it
 * introduced a slight nonuniformity because of the bias in the rounding
 * of floating-point numbers: it was slightly more likely that the
 * low-order bit of the significand would be 0 than that it would be 1.]
 *
 * @return the next pseudorandom, uniformly distributed {@code float}
 *         value between {@code 0.0} and {@code 1.0} from this
 *         random number generator's sequence
 */

InformationsquelleAutor David Tonhofer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.