Der schnellste Weg, um einen zufälligen Booleschen Wert zu generieren

Es gibt also verschiedene Möglichkeiten, einen zufälligen Bool in C # zu erstellen:

• Verwenden von Random.Next (): rand.Next(2) == 0
• Verwenden von Random.NextDouble (): rand.NextDouble() > 0.5

Gibt es wirklich einen Unterschied? Wenn ja, welches hat tatsächlich die bessere Leistung? Oder gibt es einen anderen Weg, den ich nicht gesehen habe, der vielleicht noch schneller ist?

Die erste Option - rand.Next(2)führt hinter den Kulissen den folgenden Code aus:

if (maxValue < 0)
{
    throw new ArgumentOutOfRangeException("maxValue",
        Environment.GetResourceString("ArgumentOutOfRange_MustBePositive", new object[] { "maxValue" }));
}
return (int) (this.Sample() * maxValue);

und für die zweite Option - rand.NextDouble():

return this.Sample();

Da die erste Option maxValueValidierung, Multiplikation und Casting enthält, ist die zweite Option wahrscheinlich schneller .

Kleine Verbesserung für die zweite Option :

Laut MSDN

public virtual double NextDouble()

kehrt zurück

Eine Gleitkommazahl mit doppelter Genauigkeit größer oder gleich 0,0 und kleiner als 1,0.

Wenn Sie also einen gleichmäßig verteilten zufälligen Bool möchten, sollten Sie ihn verwenden >= 0.5

rand.NextDouble() >= 0.5

Bereich 1: [0.0 ... 0.5 [
Bereich 2: [0.5 ... 1.0 [
| Bereich 1 | = | Bereich 2 |

Die schnellste. Das Aufrufen der Methode Random.Nexthat den geringeren Aufwand. Die unten stehende Erweiterungsmethode läuft 20% schneller als Random.NextDouble() > 0.5und 35% schneller als Random.Next(2) == 0.

public static bool NextBoolean(this Random random)
{
    return random.Next() > (Int32.MaxValue / 2);
    // Next() returns an int in the range [0..Int32.MaxValue]
}

Schneller als der Schnellste. RandomMit Tricks ist es möglich, zufällige Boolesche Werte mit der Klasse noch schneller zu generieren . Die 31 signifikanten Bits eines generierten intkönnen für 31 nachfolgende boolesche Produktionen verwendet werden. Die unten stehende Implementierung ist 40% schneller als die zuvor als die schnellste deklarierte.

public class RandomEx : Random
{
    private uint _boolBits;

    public RandomEx() : base() { }
    public RandomEx(int seed) : base(seed) { }

    public bool NextBoolean()
    {
        _boolBits >>= 1;
        if (_boolBits <= 1) _boolBits = (uint)~this.Next();
        return (_boolBits & 1) == 0;
    }
}

Ich habe Tests mit Stoppuhr durchgeführt. 100.000 Iterationen:

System.Random rnd = new System.Random();
if (rnd.Next(2) == 0)
     trues++;

CPUs mögen Ganzzahlen, daher war die Next (2) -Methode schneller. 3.700 gegenüber 7.500 ms, was ziemlich beachtlich ist. Außerdem: Ich denke, Zufallszahlen können ein Engpass sein. Ich habe in Unity ungefähr 50 Frames pro Frame erstellt, selbst mit einer winzigen Szene, die mein System merklich verlangsamt hat. Daher hatte ich gehofft, eine Methode zum Erstellen eines zufälligen Bools zu finden. Also habe ich es auch versucht

if (System.DateTime.Now.Millisecond % 2 == 0)
       trues++;

Das Aufrufen einer statischen Funktion war mit 9.600 ms jedoch noch langsamer. Einen Versuch wert. Schließlich habe ich den Vergleich übersprungen und nur 100.000 Zufallswerte erstellt, um sicherzustellen, dass der Vergleich zwischen int und double keinen Einfluss auf die verstrichene Zeit hat, aber das Ergebnis war ziemlich gleich.