Ich weiß, dass C++ viel schneller als Python 3 sein sollte, weil es eine kompilierte Sprache im Gegensatz zu einer interpretierten Sprache ist.Warum ist meine Python 3-Implementierung viel schneller als die, die ich in C++ geschrieben habe?
Ich schrieb 2 zwei Programme, die die Monte-Carlo-Simulation verwendenPi, einen in Python 3 und die andere in C++ zu berechnen.
Python erwies sich als ungefähr 16x schneller als C++. Wie in den folgenden Bildern zu sehen, benötigt Python mit einem Wiederholungswert von (10.000.000) 8,5 Sekunden, während C++ 137,4 Sekunden benötigt.
Ich bin neu in C++, aber ich kann keine Beiträge online finden, die dieses Verhalten erklären.
Nach this post sollte C++ im Allgemeinen 10x - 100x schneller sein als Python, was bei mir eindeutig nicht der Fall ist.
Bitte helfen Sie mir zu verstehen, warum Python in meinem Fall wesentlich schneller als C++ ist.
Meine Ergebnisse:
Monte Carlo Simulation (Estimation of Pi) in C++ 
Monte Carlo Simulation (Estimation of Pi) in Python 3 
Python-Quellcode:
from random import random
import time
import sys
class MonteCarloSimulator(object):
def __init__(self, value):
self.value = value
if sys.platform == "win32":
self.G = ''
self.R = ''
self.END = ''
else:
self.G = '\033[92m'
self.R = '\033[1;31m'
self.END = '\033[0m'
def unit_circle(self, x, y):
if (x ** 2 + y ** 2) <= 1:
return True
else:
return False
def simulate(self):
print("\nProcessing calculations with a repetition value of " + self.R +
str(self.value) + self.END + " times.")
area_of_circle = 0
area_of_square = 0
start = time.clock()
for i in range(1, self.value):
x = random()
y = random()
if self.unit_circle(x, y):
area_of_circle += 1
area_of_square += 1
pi = (area_of_circle * 4)/area_of_square
runtime = time.clock() - start
print("\tCalculated Pi = " + self.G + str(pi) + self.END +
" ({0} seconds, {1} minutes)".format(round(runtime, 10),
round(runtime/60, 10)))
print("Estimated Num of Pi is off by", abs(pi - 3.14159265359))
def main():
values = [1000, 10000, 100000, 1000000, 10000000, 100000000,1000000000, 10000000000]
for value in values: MonteCarloSimulator(value).simulate()
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\nQuitting...")
sys.exit(1)
C++ Quellcode:
#include <iostream> // std library
#include <random> // random number generator
#include <ctime> // calculating runtime
#include <cmath> // absolute value function
#include "MonteCarloSimmulation.hpp" // function prototypes
using namespace std;
const double g_PI {3.141592653589793238463};
int main()
{
// repitition values
long values[5] = {1000, 10000, 100000, 1000000, 10000000};//, 100000000, 1000000000, 10000000000};
// runs the simulation with the different repetition values
for (auto value : values)
simulate(value);
cout << "\nPress return to exit";
cin.get();
return 0;
}
/**
* The actual simulation
*/
void simulate(unsigned long value)
{
// start time for calculating runtime
const clock_t startTime = clock();
// area's variables
unsigned long area_of_circle = 0;
unsigned long area_of_square = 0;
// print the repitiion value
cout << "\nProcessing calculations with a repetition value of " << value <<
" times." << endl;
for (unsigned long i = 0; i != value; i++)
{
// gets random values from 0 to 1 for (x) and (y)
float x = randomFloat();
float y = randomFloat();
// checks if (x, y) are in a unit circle, if so increment circle area
if (unit_circle(x, y))
area_of_circle++;
area_of_square++;
}
// pi = area of circle * 4/area of square
double calculatedPi = static_cast<double>(area_of_circle * 4)/area_of_square;
float endTime = static_cast<float>(clock() - startTime)/CLOCKS_PER_SEC;
// prints the value of calculated pi
cout << "\tCalculated Value of Pi: " << calculatedPi <<
" (" << endTime << " seconds, " << endTime/60 << " minutes)" << endl;
// difference between the calc value and pi
cout << "Estimated Num of Pi is off by " << abs(calculatedPi - g_PI) << '\n';
}
/**
* returns a random number from 0 to 1
*/
float randomFloat()
{
random_device rd;
default_random_engine generator(rd()); // rd() provides a random seed
uniform_real_distribution<float> distribution(0,1);
float x = distribution(generator);
return x;
}
/**
* checks if the two input parameters are inside a unit circle
*/
bool unit_circle(float x, float y)
{
if ((x*x + y*y) <= 1)
return true;
else
return false;
}
Der Quellcode ist offensichtlich erforderlich, Ich denke. – Delgan
* "Bei Bedarf werde ich den Quellcode für beide Programme veröffentlichen" * - wie können wir die Ergebnisse ohne es verstehen? – Galik
Es wird fast seine ganze Zeit im Zufallszahlengenerator verbringen, der in beiden Fällen kompilierter Code ist. So würde ich zuerst schauen. –