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 benediktg Antwort abbrechen