- Modificato
Dopo aver parlato di un confronto performance fra Julia, R, Python, MATLAB, vediamo ora un altro benchmark interessante: risoluzione numerica dell'integrale definito di una funzione gaussiana, confronto di prestazioni fra i seguenti linguaggi:
- C, codice standard
- C, codice ottimizzato
- Python 3.9.2
- MATLAB (GNU Octave 6.2.0)
- JavaScript (script in HTML su Chromium 104.0.5112.101)
- PHP 7.4.30
È stato fatto uso di una funzione per misurare il tempo di esecuzione del codice in secondi (end-start), 10 campionamenti per ogni caso, poi fatta la media e riportati i valori graficamente, normalizzandoli con C_opt (l'algoritmo scritto in C "ottimizzato"); quindi C_opt ha valore 1, gli altri più sono elevati e più sono inefficienti per risolvere questo algoritmo computazionale, richiedono quindi tempo maggiore. Infine l'immagine mostra tutti i risultati e il grafico di benchmark. Sistema operativo Linux Parrot OS 5.1, 64bit (Kernel Linux 5.18.0-14parrot1-amd64 x86_64).
Riportiamo di seguito il codice nei vari casi:
- C, codice standard:
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <math.h> float f(float x); int main(){ clock_t start = clock(); float ris=0; int N=1000000; float a=0; float b=20; float h=(b-a)/N; int i; for(i=0;i<N;i++){ ris+=h*f(a+i*h); } clock_t end = clock(); printf("%f\n",(float)(end-start)/CLOCKS_PER_SEC); return 0; } float f(float x){ return pow(1/(2*M_PI),0.5)*pow(M_E,(-0.5*x*x)); }
- C, codice ottimizzato (C_opt):
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <math.h> int main(){ clock_t start = clock(); register int N=1000000; register float ris=0; register float a=0; register float b=20; register float h=(b-a)/N; register int i; for(i=0;i<N;i++){ ris+=pow(1/(2*M_PI),0.5)*pow(M_E,(-0.5*(a+i*h)*(a+i*h))); } clock_t end = clock(); printf("%f\n",(float)(end-start)/CLOCKS_PER_SEC); return 0; }
- Python 3.9.2:
import time import numpy as np start=time.time() ris=0 N=10**6 a=0 b=20 h=(b-a)/N def f(x): return 1/(2*np.pi)**0.5*np.exp(-x**2/2) for i in range(0,N): ris+=h*f(a+i*h) print("ris=",ris) end=time.time() print(end-start,"s")
- MATLAB (GNU Octave 6.2.0):
clear all close all clc tic ris=0; N=1000000; a=0; b=20; h=(b-a)/N; for i=0:N ris=ris+1/(2*3.141592653589793)^0.5*2.718281828459045^(-0.5*(a+i*h)*(a+i*h)); end toc
- JavaScript (script all'interno di una pagina HTML):
<html> <script> var start=performance.now(); var ris=0; var N=10**6; var a=0; var b=20; var h=(b-a)/N; function f(x){ return 1/(2*3.141592653589793)**0.5*2.718281828459045**(-0.5*x**2) } for(i=0;i<N;i++){ ris+=h*f(a+i*h); } var end=performance.now(); document.write("ris="+ris+"<br>") document.write(end-start+"ms") </script> </html>
- PHP 7.4.30:
<?php $start=microtime(TRUE); $ris=0; $N=10**6; $a=0; $b=20; $h=($b-$a)/$N; function f($x){ return 1/(2*3.141592653589793)**0.5*2.718281828459045**(-0.5*$x**2); } for($i=0;$i<$N;$i++){ $ris+=$h*f($a+$i*$h); } $end=microtime(TRUE); echo "ris=".$ris."\n"; echo $end-$start."s"; ?>
I risultati sono mostrati nella seguente immagine: mostra chiaramente che le performance migliori sono ottenute da C (sia "ottimizzato" che "standard"), PHP e JavaScript risultano accettabili, Python e MATLAB (GNU Octave) risultano estremamente inefficienti (67 e 92 volte più lenti del codice C ottimizzato).
Interessante anche la deviazione standard dei campionamenti, il tempo di esecuzione di C, così come PHP, ha bassa variabilità, valori sempre molto simili; JavaScript e MATLAB hanno più variabilità, Python ancora molta più variabilità.
Risultati (normalizzando rispetto a C_opt):
- C_opt = 1
- C, standard = 1,2367
- Python = 67,16
- MATLAB = 92,463
- JavaScript = 3,84
- PHP = 2,6289