Java est-il lent pour le calcul pur

**bilibou** · 20/04/2007, 19h25

Bonjour,

Je travaille sur un logiciel qui me permet a partir d'une transformée (celle de joukovsy ) de calculer la vitesse de l'écoulement de l'air autour d'une aile d'avion
voici la formule :

dzeta et mu sont des complexes ainsi que eialpha. je dois effectuer cette formule 16000 fois et actuellement cela demande un temps de calcul vraiment trés impressionnant.

Je voulais donc savoir si le java était particulièrement lent pour le calcul (j'ai un pote qui a fait la même chose en delphi et le calcul lui prend 5 secondes grand maxi) , si non ben j'ai du me planter quelque part si oui si vous pouviez me communiquer quelques clés pour optimiser le calcul dans java ce serait cool.

Merci d'avance

A+

Au fait pour ceux qui veulent plus d'infos sur la transformée de joukowsky c'est par là : http://fr.wikipedia.org/wiki/Transfo...e_de_Joukovsky

**®om** · 20/04/2007, 19h26

Tu peux déjà nous montrer ton code, au cas où des optimisations seraient visibles aussitôt?

**bilibou** · 20/04/2007, 19h39

salut ,

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
29
30
31
32
33
[public Complex[][] vitesse() {
		double gamma,rho2,theta;
		Complex z0,z,W;
		Complex tableau[][] = new Complex[400][400];
		z0 = new Complex(reelle,imaginaire);
		//if (kutta = true) {gamma = 4*Math.PI*r*(alpha + Math.asin(imaginaire/r));}
		//else {gamma = 4*Math.PI*r*(alpha + Math.asin(imaginaire/r));} ;
		for (int i=0; i<400; i++){
			for (int j=0; j<400; j++) {
				rho2=(i-200)*(i-200)+(j-200)*(j-200);
				theta = -Math.atan2(j-200, i-200);
				z = new Complex(rho2*Math.cos(theta-alpha),rho2*Math.sin(theta-alpha));
				W = vitesseComplex(z0,z,alpha,vitesseInfinie,r);
				tableau[i][j] = W;
			}
		}
				return tableau;
	}
 
	//Fonnction retournant la vitesse complexe
	private Complex vitesseComplex(Complex z0,Complex z,double alpha, double gamma, double r) {
		Complex vitesseInfinicpx, Zcircul,tmp,tmp2,terme3;
		vitesseInfinicpx = new Complex(gamma*Math.cos(alpha),gamma*Math.sin(alpha));
		tmp2 = z.minus(z0);
 
		tmp = new Complex(0,gamma/(Math.PI*2));
		Zcircul = tmp.div(tmp2);
 
		tmp = new Complex(-vitesseInfinie*r*r*Math.cos(alpha),-vitesseInfinie*r*r*Math.sin(alpha));
		terme3 = tmp.div(tmp2.times(tmp2));
 
		return terme3.plus(vitesseInfinicpx.plus(Zcircul));
	}

Bon peut être que ça ne corespond pas parfaitement à la formule parce que là je suis plus en train d'esssayer de voir la méthode qui me coutera le moins de temps je ne m'interesse pas trop à l'exactitude.
Et dans le cas général est-ce que vous pensez que d'effectuer cette formule 16000 fois en java est raisonnable ou ça va me prendre vraiment trop de temps.

**bilibou** · 21/04/2007, 12h03

Bon voila une version du code un peu plus optimisé (le calcul prend environ 10 minutes) mais c'est toujours lamentablement lent par rapport au même calcul executé en delphi (surtout qu'il a été réalisé avec un classe gerant les nombres complex ,à chaque tour de boucle il y avait la création de 4 complexes... donc normalement ce serait beaucoup plus long)

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
29
30
31
32
33
34
35
	public double[][][] vitesse() {
		double reDenomTerme2carre,reDenomTerme24,imDenomTerme2carre,temp1Terme2,temp1Terme3,temp2Terme3,temp3Terme3,temp4Terme3,temp1,temp2;
		double gamma,reTerme1,imTerme1,imNumTerme2,reNumTerme3,imNumTerme3,reDenomTerme2,imDenomTerme2,reDenomTerme3,imDenomTerme3,reTerme2,imTerme2,reTerme3,imTerme3; 
		double tableau[][][] = new double[400][400][2];
		reTerme1 = vitesseInfinie*Math.cos(alpha);
		imTerme1 = vitesseInfinie*Math.sin(alpha);
		if (kutta = true) {gamma = 4*Math.PI*r*(alpha + Math.asin(imaginaire/r));}
		else {gamma = 4*Math.PI*r*(alpha + Math.asin(imaginaire/r));} ;
		imNumTerme2 = gamma/(2*Math.PI);
		reNumTerme3 = vitesseInfinie*r*r*Math.cos(alpha);
		imNumTerme3 = vitesseInfinie*r*r*Math.sin(alpha);
		for (int i=0; i<400; i++){
			reDenomTerme2 = (i - reelle);
			reDenomTerme2carre = reDenomTerme2 * reDenomTerme2;
			reDenomTerme24 = reDenomTerme2carre;
			temp1Terme2 = imNumTerme2 * reDenomTerme2;
			temp1Terme3 = reDenomTerme2carre * reNumTerme3;
			temp2Terme3 = 2 * reDenomTerme2 * imNumTerme3;
			temp3Terme3 = reDenomTerme2carre * imNumTerme3;
			temp4Terme3 = 2 * reDenomTerme2 * reNumTerme3;
			for (int j=0; j<400; j++) {
				imDenomTerme2 = (j - imaginaire);
				imDenomTerme2carre = (j - imaginaire)*(j - imaginaire);
				temp1 = reDenomTerme2carre + imDenomTerme2carre;
				reTerme2 = (imNumTerme2 * imDenomTerme2) / temp1;
				imTerme2 = (imNumTerme2 * reDenomTerme2) / temp1;
				temp2 = reDenomTerme24 + imDenomTerme2carre * imDenomTerme2carre + 2*reDenomTerme2carre*imDenomTerme2carre;
				reTerme3 = (temp1Terme3 - imDenomTerme2carre * reNumTerme3 - temp2Terme3 * imDenomTerme2)/temp2;
				imTerme3 = (temp3Terme3 - imDenomTerme2carre * imNumTerme3 - temp3Terme3 * imDenomTerme2)/temp2;
				tableau[i][j][0] = reTerme1 + reTerme2 + reTerme3;
				tableau[i][j][1] = imTerme1 + imTerme2 + imTerme3;	
			}
		}
				return tableau;
	}

Voila donc si vous avez des astuces à me donner (quitte à rajouter une partie de code en C dans mon programme je suis preneur).
Bon rajouter du code en C c'est en dernier recours quand même, j'aimerais bien ne pas perdre l'avantage de la portabilité de java.

A++

**®om** · 21/04/2007, 12h52

Tu peux donner le code de chacune des classe (ou alors le projet en archive), pour pouvoir tester?

**bilibou** · 21/04/2007, 13h04

Merci de ton aide mais j'ai trouvé mon erreur et tout d'un coup je me sens trés trés con

En fait pour tester la vitesse du calcul je faisais ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Base vitesse = new Base(2,2);
		for (int i=0; i<400;i++) {
			for(int j=0; j<400;j++) {
				System.out.println(vitesse.vitesse()[i][j][0] + "//" + i + j);
			}
 
		}
		System.out.println("good");
	}

et puis je me suis rendu compte que en fait cela devait calculer 16000 fois le tableau donc j'ai transformé mon code comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
		// TODO Auto-generated method stub
		Base vitesse = new Base(2,2);
		double tableau[][][] = vitesse.vitesse();
		for (int i=0; i<400;i++) {
			for(int j=0; j<400;j++) {
				System.out.println(tableau[i][j][0] + "//" + i + j);
			}
 
		}
		System.out.println("good");
	}

et voila comme par miracle cela ne met plus que 2 secondes, et moi devant mon écran qui me sent un peu bête sachant que ça fait 2 jours que je cherche l'erreur .

Bon on mettra sur le compte du fait que je débute.

En tous cas merci pour ton aide et puis bon peut être que ce message servira peut être à quelqu'un d'autre.

A++