un peu de Math

Bonjour,
je voudrais connaitre la distance entre deux points dont je connais la longitude et la latitude.
J'ai trouvé cette formule :

AB = acos(sin(LatRadA)*sin(LatRadB) + cos(LatRadA)*cos(LatRadB)*cos(LongRadB-LongRadA));

Les valeurs de la longitude et de latitude doivent à par rament etre converti en radian.

Malheureusement quand je programme ça sos visual C++, je n'arrive pas à obtenir la bonne distance.

Est ce que qqun à une suggestion?

Merci

ou est defini le rayon terrestre ..?

double post ... raté !

Pour ma part, j'ai ceci :

Code:

---

1 2 3 4 5

double calcdist( double LT1, double LG1, double LT2, double LG2 ) // en metres { double D = rayonterre(LT1) * acos((cos(D2R*LT1) * cos(D2R*LT2) * cos(D2R*(LG2-LG1))) + (sin(D2R*LT1) * sin(D2R*LT2))); return D; }

---

D2R est un zolie macro pour convertir les deg en rad
rayonterre est un fonction qui renvoie le rayon terrestre (lié à la latitude):

Code:

---

1 2 3 4 5 6 7 8 9

// Rayon terrestre #define Rmax 6378140 // a l'equateur #define Rmin 6356755 // au pole   double rayonterre( double LT ) { double R = ( Rmax + Rmin ) / 2.; // rayon moyen R += ( ( Rmax - Rmin ) / 2. ) * cos( 2 * LT * D2R ); // variation du rayon return R; }

---

Tu veux aussi le cap ..? :D

Citation:

---

Envoyé par Dje14

ou est defini le rayon terrestre ..?

---

Bien d'accord ! sinon je pense que ce sujet serait plus approprié sur le forum Algorithmes...

A+

pour le rayon terrestre j'ai oublier de le mettre, mais il suffit de multiplier le formule par le rayon de la terre

Citation:

---

Envoyé par Dje14

double post ... raté !

Pour ma part, j'ai ceci :

Code:

---

1 2 3 4 5

double calcdist( double LT1, double LG1, double LT2, double LG2 ) // en metres { double D = rayonterre(LT1) * acos((cos(D2R*LT1) * cos(D2R*LT2) * cos(D2R*(LG2-LG1))) + (sin(D2R*LT1) * sin(D2R*LT2))); return D; }

---

D2R est un zolie macro pour convertir les deg en rad
rayonterre est un fonction qui renvoie le rayon terrestre (lié à la latitude):

---

A quoi ressemble ta macro D2R stp?

merci

bein ...
#define D2R 0.0174532925199433
c'est 180./Pi pour éviter de rajouter des calculs dans le code
Tu sais faire une regle de 3 quand même ..? 8O

Mais si tu ne copies pas betement mon code, tu n'en a pas besoin vu que tes coordonnees sont deja en radians

Citation:

---

Envoyé par Dje14

#define D2R 0.0174532925199433
c'est 180./Pi pour éviter de rajouter des calculs dans le code

---

Beark !

Si tu veux une constante égale à 180/Pi, pourquoi ne pas écrire :

Code:

---

double const D2R = 180/Pi;

---

Parce que vu que c'est une partie critique en perf de mon prog, j'ai préféré limiter les calcules (cible : ARM sans fpu) 4 / en moins c'est bien !

Juste pour la curiosité mais le compilateur remplace betement? Il ne fait pas le calcul une seule fois?

Citation:

---

Parce que vu que c'est une partie critique en perf de mon prog, j'ai préféré limiter les calcules (cible : ARM sans fpu) 4 / en moins c'est bien !

---

Citation:

---

Juste pour la curiosité mais le compilateur remplace betement? Il ne fait pas le calcul une seule fois?

---

Justement, l'intêret de remplacer une macro par une variable constante est de faire le calcul une et une seule fois.

Je crois que le compilateur remplace l'appel de la macro par le code de la macro a la premiere passe. (Ce qui peut d'ailleurs poser des problèmes au debugguage)

As tu fait les mesures de perf ?
En utilisant une constante calculable à la compilation, qu'est-ce qui pourrait être une baisse de perf par rapport à l'utilisation d'un macro ?

J'ai dans l'idée qu'il est plus rapide de faire a = 123.456 que b = 123456./1000.
Maintenant, c'est plus un choix d'implémentation qu'une modification pour rendre le prog plus rapide.

Citation:

---

Envoyé par Dje14

J'ai dans l'idée qu'il est plus rapide de faire a = 123.456 que b = 123456./1000.
Maintenant, c'est plus un choix d'implémentation qu'une modification pour rendre le prog plus rapide.

---

Oui mais ce calcul est effectué une seule fois au lancement du programme... Alors est-ce bien important ? D'autant plus que n'importe quel bon compilo inscrira certainement directement le résultat dans le code généré.

Citation:

---

Envoyé par Dje14

J'ai dans l'idée qu'il est plus rapide de faire a = 123.456 que b = 123456./1000.

---

J'ai dans l'idée que tu te trompes. Par exemple, avec VC++ (mais je suis prêt à mettre ma main à couper que c'est pareil avec n'importe quel compilateur), et en mode non optimisé, le programme :

Code:

---

1 2 3 4 5 6 7 8

int main() { int a = 420/10; int a1 = 42; double b = 420./10.; double b1 = 42.; return a/b; }

---

Génère le code assembleur suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int a = 420/10; 0041134E mov dword ptr [a],2Ah int a1 = 42; 00411355 mov dword ptr [a1],2Ah double b = 420./10.; 0041135C fld qword ptr [__real@4045000000000000 (415750h)] 00411362 fstp qword ptr [b] double b1 = 42.; 00411365 fld qword ptr [__real@4045000000000000 (415750h)] 0041136B fstp qword ptr [b1] return a/b; 0041136E fild dword ptr [a] 00411371 fdiv qword ptr [b] 00411374 call @ILT+185(__ftol2_sse) (4110BEh)

---

je confirme : les compilateurs remplacent les expressions utilisant des constantes par la valeur correspondante

Ah !!
Bein merci pour l'info ! :)