Bonjour,

Comme j'en ai déjà parlé, j'ai un code qui s'exécute pratiquement 100 fois plus vite en Fortran qu'en Python ...

Cet écart important me surprend car j'utilise numpy qui, je crois, accélère les calculs ...

J'ai fait un essai sur un bout de code très simple que j'exécute un million de fois et dont je mesure le temps d'exécution ...

verdict : 0,48 secondes en Fortran pour 9,23 secondes en Python/Numpy; soit pratiquement un facteur 40

Et sans Numpy, le code Python met 325 secondes soit un facteur 700 !!!

voici le bout de code en Python :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding: cp1252 -*-
import numpy as np
from time import *

# creation de 5 arrays Numpy 
dimension = 40
f = np.ndarray(shape =(dimension),dtype=np.float)
h = np.ndarray(shape =(dimension),dtype=np.float)
w = np.ndarray(shape =(dimension),dtype=np.float)
e = np.ndarray(shape =(dimension),dtype=np.float)
t = np.ndarray(shape =(dimension),dtype=np.float)
# remplissage des arrays Numpy
h.fill (10.)
w.fill (1000.)
e.fill (290.)
t.fill (300.)

t1 = time()  # recuperation du temps système
i = 0
while (i < 1000000):  # execution de un million de calcul
    f = h * w * ( e - t ) # calcul
    i = i +1

print 'temps pour un million de passages:', (time() - t1)
Et pour ceux qui lisent le Fortran, le même en Fortran, les opérations Numpy sont remplacées par des boucles :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
USE DFPORT
	implicit none
	real t1, t2
	real temps(2)
	integer n, i, j
	
	! déclaration de 5 tableaux
	parameter (n=40)
	real f(n),h(n), w(n), e(n), t(n)
	
	! remplissage des tableaux
	do i = 1,n
		h(i) = 10.
		w (i) = 1000.
		e (i) = 290.
		t (i) = 300.
	enddo 

	t1= dtime(temps) ! récupération du temps système avant calcul
	do i = 1, 1000000  ! boucle pour un million de calcul
		do j = 1, n  ! boucle remplaçant les opérations Numpy
			f(j) = h(j) * w(j) * ( e(j) - t(j) )
		enddo
	enddo	
	t2 = dtime(temps) ! récupération du temps système après calcul
	write (6,*) 'temps pour un million de passages:',temps(1) + temps(2)
	
	end
N'y a t-il pas moyen de faire plus rapide avec Python?

En utilisant Numpy, je m'attendais à avoir quelque chose 2 à 3 fois plus lent que Fortran mais j'étais loin de penser à un facteur 40 à 100

Est ce normal?
Est ce que je fais quelque chose de mal?



Bon dimanche