Vor einiger Zeit habe ich von der sogenannten Leibniz-Reihe erfahren. Mit diesem Verfahren kann man Pi errechnen. Und wenn man schon dabei ist einen Benchmark durchführen 🙂
Ich habe den Programmcode in fünf Programmiersprachen umgesetzt (Fehler schließe ich hier nicht aus und ich freue mich über Hinweise) und zwar:
Python:
#!/usr/bin/python3
#Berechne Pi mit der Leibniz-Reihe
import time
iterations = 1000000
x = 1
pi = 1
start = time.time()
for i in range(2, iterations + 2):
x = x * -1
pi = pi + (x / (2*i-1))
pi = pi * 4
end = time.time()
print('Pi: ' + str(pi))
print('Time taken for ' + str(iterations) + ' Iterations: ' + str((end - start)*1000000) + ' Mikroseconds')
Javascript:
var iterations = 1000000;
var x = 1;
var pi = 1;
var begin=Date.now();
for (i = 2; i < iterations + 2; i++) {
x = x * -1;
pi = pi + (x / (2*i-1));
}
pi = pi * 4;
var end= Date.now();
console.log('Pi: ' + pi);
console.log('Took ' + ((end-begin)*1000) + ' Microseconds');
PHP:
<?php
$iterations = 1000000;
$x = 1;
$pi = 1;
$begin = microtime(true);
for ($i = 2; $i < $iterations + 2; $i++) {
$x = $x * -1;
$pi = $pi + ($x / (2*$i-1));
}
$pi = $pi * 4;
$end = microtime(true) - $begin;
echo('Pi: ' . $pi . "\n");
echo('Took ' . ($end * 1000 * 1000) . ' Microseconds' . "\n");
?>
C:
#include <stdio.h>
#include <sys/time.h>
int main()
{
struct timeval start, end;
long secs_used, micros_used;
int iterations = 1000000;
float x = 1;
float pi = 1;
gettimeofday(&start, NULL);
for (int i = 2; i < iterations + 2; i++) {
x = x * -1;
pi = pi + (x / (2.0*i-1.0));
}
pi = pi * 4;
gettimeofday(&end, NULL);
secs_used = (end.tv_sec - start.tv_sec);
micros_used = ((secs_used*1000000) + end.tv_usec) - (start.tv_usec);
printf("Pi: %f\n", pi);
printf("micros_used: %ld\n", micros_used);
}
C#:
using System;
using System.Diagnostics;
namespace Leibniz
{
class Program
{
static void Main(string[] args)
{
int iterations = 1000000;
double x = 1;
double pi = 1;
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 2; i<iterations + 2; i++) {
x = x* -1;
pi = pi + (x / (2.0*i-1.0));
}
pi = pi* 4;
stopwatch.Stop();
Console.WriteLine("Pi: " + pi);
Console.WriteLine("micros_used: " + stopwatch.ElapsedMilliseconds * 1000);
}
}
}
Und C für Arduino:
void setup() {
Serial.begin(9600);
}
void loop() {
unsigned long iterations = 1000000;
Serial.println("Start");
float x = 1;
float pi = 1;
unsigned long starttime = micros();
for (unsigned long i = 2; i < iterations + 2; i++) {
x = x * -1;
pi = pi + (x / (2.0*i-1.0));
}
pi = pi * 4;
unsigned long endtime = micros();
Serial.print("Pi: ");
Serial.println(pi);
Serial.print("Micros used: ");
Serial.println(endtime - starttime);
}
Und hier gibt es ein paar Messergebnisse zu den obigen Programmcodes:
| Python3 auf dem PC | 258213 µsec | 000.250 sec |
| Javascript auf dem PC (Node.JS) | 27000 µsec | 000.027 sec |
| Javascript auf dem PC (Firefox) | 1637000 µsec | 001.637 sec |
| Javascript auf dem PC (Chrome) | 297000 µsec | 000.297 sec |
| C auf dem PC | 5371 µsec | 000.005 sec |
| Javascript auf dem EspruinoPico | 458677532 µsec | 458.677 sec |
| Python auf dem PyBoard | 26000000 µsec | 026.000 sec |
| C auf dem Arduino Uno | 57328564 µsec | 057.329 sec |
| Python auf dem RasPi 1 | 3251917 µsec | 003.252 sec |
| C auf dem RasPi 1 | 83939 µsec | 000.084 sec |
| Javascript auf dem RasPi 1 (Node.JS) | 178000 µsec | 000.178 sec |
| C# | 3000 µsec | 000.003 sec |
| PHP7 CLI | 61338 µsec | 000.061 sec |
| PHP7 Browser | 66730 µsec | 000.066 sec |
Das schöne hier dran ist dass man diesen Programmcode so ziemlich in jeder Sprache und auf jeder Hardware durchführen kann.
Selbstverständlich zeigt dieser Test nicht wie schnell die jeweilige Sprache/Hardware tatsächlich ist, sondern nur wie schnell sie mit Float-Berechnungen umgehen kann. Ein massiver Unterschied besteht natürlich wenn die jeweilige Hardware keine extra Floating Point Hardware besitzt (wie z.B. der Arduino Uno).
Schreibe einen Kommentar zu Marius Müller Antworten abbrechen