Unterschied zwischen C++ Zufallszahlengenerierung und Python

Question

Ich versuche, einige Python-Code in C++ zu übersetzen. Was der Code tut, ist eine Monte-Carlo-Simulation auszuführen. Ich dachte, die Ergebnisse von Python und C++ könnten sehr nahe liegen, aber es scheint etwas Lustiges passiert zu sein. Hier

ist, was ich in Python zu tun:

self.__length = 100 
self.__monte_carlo_array=np.random.uniform(0.0, 1.0, self.__length) 

Hier ist, was ich in C tun ++:

int length = 100; 
std::random_device rd; 
std::mt19937_64 mt(rd()); 
std::uniform_real_distribution<double> distribution(0, 1); 

for(int i = 0; i < length; i++) 
{ 
    double d = distribution(mt); 
    monte_carlo_array[i] = d; 
} 

ich oben Erzeugung von Zufallszahlen lief mal 100x5 sowohl in Python und C++, und dann Mach Monte Carlo Simulation mit diesen Zufallszahlen.

In Monte Carlo Simulation, setze ich den Schwellenwert als 0,5, so kann ich leicht überprüfen, ob die Ergebnisse gleichmäßig verteilt sind. Hier

ist ein Konzeptentwurf, was Monte Carlo Simulation tut:

for(i = 0; i < length; i++) 
{ 
    if(monte_carlo_array[i] > threshold) // threshold = 0.5 
     monte_carlo_output[i] = 1; 
    else 
     monte_carlo_output[i] = 0; 
} 

Da der Länge der Monte-Carlo-Array 120, erwarte ich 60 1 s zu sehen, sowohl in Python und C++. Ich berechne die durchschnittliche Anzahl von 1 s und festgestellt, dass, obwohl die durchschnittliche Anzahl in C++ und Python ist rund 60, aber der Trend sind stark korreliert. Darüber hinaus ist die durchschnittliche Anzahl in Python immer höher als in C++.

Darf ich wissen, ob dies daran liegt, dass ich etwas falsch gemacht habe, oder einfach weil der Unterschied zwischen zufälligen Generierungsmechanismen in C++ und Python besteht?

[Bearbeiten] Bitte beachten Sie, dass die RNG in Python ist auch die Mersenne-Twister-19937.

Answer 1

ich dies basierend schrieb auf dem Code geschrieben:

import numpy as np 

length = 1000 
monte_carlo_array=np.random.uniform(0.0, 1.0, length) 
# print monte_carlo_array 
threshold = 0.5 
above = 0 

for i in range (0,length): 
    if monte_carlo_array[i] > threshold: 
     above+=1 
print above 

und dies in C++:

#include <random> 
#include <iostream> 

int main() 
{ 
    const int length = 1000; 
    std::random_device rd; 
    std::mt19937_64 mt(rd()); 
    std::uniform_real_distribution<double> distribution(0, 1); 
    double threshold = 0.5; 
    double monte_carlo_array[length]; 

    for(int i = 0; i < length; i++) 
    { 
     double d = distribution(mt); 
     monte_carlo_array[i] = d; 
    } 
    int above = 0; 

    for(int i = 0; i < length; i++) 
    { 
     if (monte_carlo_array[i] > threshold) 
     { 
      above++; 
     } 
    } 
    std::cout << above << std::endl; 
} 

Fünf Durchläufe ergeben:

Python: 
480 
507 
485 
515 
506 
average: 
498.6 

C++: 
499 
484 
531 
509 
509 
average 
506.4 

Also, wenn ich etwas finde, dass C++ höher ist als Python. Aber ich denke, es ist mehr ein Fall von "Zufallszahlen sind nicht gleichmäßig mit einer kleinen Anzahl von Proben verteilt."

ich geändert Länge bis 100000 statt, und immer noch die Ergebnisse variieren nach oben und unten um 50k:

Python: 

50235 
49752 
50215 
49717 
49974 

Average: 
49978.6 

C++: 

50085 
50018 
49993 
49779 
49966 

Average: 
49968.2 

Zusammenfassend, ich glaube nicht, dass es irgendwelche großen Unterschied zwischen den Zufallszahl-Implementierungen in C++ und Python wenn es darum geht, "wie uniform ist es um 0,5". Aber ich habe Statistiken nicht sehr oft studiert (und das war vor vielen Jahren).

Answer 2

Wenn Sie nicht sicher sind, in Zufallszahlen nur eine große Anzahl von Zufallszahlen generieren, indem Sie Service wie Random ORG verwenden. Danach wird diese Nummer als Array in beiden Implementierungen (C++ und Python) angegeben. Auf diese Weise werden Sie sicher sein, dass beide Programme den gleichen Satz von Zufallszahlen verwenden und Sie können bestätigen, dass der Rest des Codes in Ordnung ist.