Module et changement de précision

Bonjour,

Voilà mon problème. Je dois moderniser un code fortran qui utilise les blocs Common en les remplacant par des modules. Une fois celà fait, je constate que les calculs effectués par le programme change petit à petit pour ne plus ressembler du tout à ceux obtenus avec la version précédente. Celà laisse suggérer un changement de précision de certaines variables mais je les ais toutes vérifiées et leurs déclarations n'ont pas changés (seuls celles déclarées implicitement ont été déclarés explicitement en conservant le bon type). les variables sont des real ou integer.

Est-ce que quelqu'un aurait eu une idée du pourquoi du comment ? Le type implicite de variable ne commencant pas par i,j,k,l,m,n est bien real ?

Merci de votre aide !

Bonjour

Pour le type implicite, ça dépend. Si rien n'est écrit dans le programme, je crois que le défaut est :

Code:

---

implicit real (a-h,o-z)

---

Mais, il est plus fréquent d'écrire :

Code:

---

implicit real*8 (a-h,o-z)

---

Les deux cas sont différents. Il y a encore une histoire de defaut (mais qui peut dépendre du compilateur ou de la machine).

la déclaration real est en fait real*4.

Si tu ne connais pas le 77 :
real*4 est équivalent à real(kind=4) c'est un réel simple précision. Déclaration équivalente :

Code:

---

1 2 3 4

real :: x real*4 :: x real(kind=4) ::x

---

real*8 est équilvalent à real((kind=8) ou double precision c'est un réel double precision déclaration équivalente :

Code:

---

1 2 3 4

real*8 :: x real(kind=8) ::x double precision :: x

---

Donc si dans ton code 77 tu avais implicit real*8, dans ton code avec module tu dois mettre double precision ou real(kind=8).

Ceci étant dit. Tout réel est arrondi, et les erreurs d'arrondis dépendent de la machine, de la charge du processeur ect ... donc il est possible que les résultats de deux programmes diffèrent un petit peu. Je ne sais pas à quoi sert ton programme, mais tu as l'air de suivre un résultat en fonction de l'avancement (une trajectoire ?). Dans ce cas, les deux trajectoires peuvent être différentes mais la moyenne sur la trajectoire doit être identique (ou presque).

Bon courage

qu'entend-tu exactement par 'changent petit à petit' ???

et par défaut si tu ne mets rien (pas bien) au début d'un prog/subroutine/fonction/module c'est exactement pareil que:

Code:

---

1 2 3

implicit integer implicit real (a-h,o-z)

---

donc toute variable i* j* k* l* m* n* est integer (kind=4) et toute les autre sont des réél simple précision (sous PC (Linux ou windows): kind=4)

de plus si c'est au court d'un calcul que cela varie, c'est peut-être une variable que tu modifie alors qu'il ne le fallait pas!!!
pour cela je suggère des déclaration 100% explicite (et je milite pour cela!!! surtout avec mes élèves!!! :p )
et donc, par exemple pour une 'function toto(e,es,s)' avec toto,es,s tous des tableaux, e un entier et e est une entrée pure es une entrée sortie et s une sortie pure, le cartouche de déclaration donnerai:

Code:

---

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

function toto(e,es,s) <eventuelement des use> implicit none integer, intent(in) :: e real(kind=8),dimension(:,:,:,:),intent(inout) :: es real(kind=8),dimension(:),intent(out) ::s real(kind=8),dimenssion(e,e) :: toto ... e=8 !<<<<<<<<<erreur on ne peut stocker dans e es(1,1,1,1)=s(1) <<<<<<<erreur on ne peut lire dans s ... end function toto

---

bon dans l'idéal, il ne faut utiliser que des entrée ou sortie pure et éviter autant que possible les variable que j'appele 'de passage' mais parfois on ne peut faire autrement... ;)