Bonjour à tous,
 
Mes excuses d'avance pour ce post qui va etre un peu long, mais le problème que je rencontre n'est pas simple à expliquer.
 
Voila, je reprends en ce moment un ancien code en Fortran 77 pour le compléter avec de nouvelles fonctions. Avant cela, j'ai entrepris de le dépoussiérer un peu, et en particulier d'accorder un soin particulier aux declarations de variables, qui étaient toutes faites de manière implicite...
 
Le programme consiste à effectuer des calculs à l'intérieur d'une boucle principale, et d'écrire les résultats dans un fichier de sortie à chaque itération.
Au niveau de la console, le programme est "silencieux" , mis à part qques messages qui signalent que tout se passe bien.
 
A l'éxécution, TOUT SE PASSE EFFECTIVEMENT BIEN (les valeurs obtenues en fin de calcul sont vérifées par un moyen parallèle), j'insiste particulièrement sur ce point qui est important pour la suite.
OR, lorsque j'ouvre mon fichier de sortie j'obtiens ceci :
 
     N     OBJ TOT MAX     OBJ TOT MIN     OBJ TOT MOY    
     0     0.500300E+01    0.407003E-05    0.773183E+00
     1     NaN                  NaN                 NaN
     2     NaN                  NaN                 NaN
     3     NaN                  NaN                 NaN
     4     NaN                  NaN                 NaN
     5     NaN                  NaN                 NaN
 
Je n'ai mis que les 5 première itérations, mais ca continue comme ca jusqu'au bout.
 
La ou ca commence à devenir étrange, c'est que les valeurs affichées sont issues de variables "object_tot" qui est utilisée telle quelle dans les calculs aux itérations suivantes, donc CE NE SONT PAS DES "VRAIS" NaN, puisque le calcul aboutit normalement. Cela est de plus confirmé par le fait que j'écris un autre fichier de sortie ou la variable "object_tot" est utilisée , et la les valeurs sont correctes.
 
Malgré cela, j'ai entrepris, par des WRITE(*,*) successifs, de "pister" l'endroit ou se produti le problème jusqu'à une sous-routine un peu en amont. Mais la le plus étrange se produit :
Si, à l'intérieur de cette sous-routine, j'écris (pop_size etant la logical size de object_tot):
"DO i=1,pop_size
      WRITE(*,*) object_tot(i)
END DO "
Alors j'obtiens des valeurs correctes pour object_tot, ET LE FICHIER DE SORTIE AFFICHE LES BONNES VALEURS!!!!!
Autrement dit, un simple "write" de la variable qui pose problème corrige le problème, sans qu'aucune modificication portant sur le fonctionnement du code n'ait été réalisée...
 
Au final, tout se passe comme si, auniveau interne, les valeurs avaient la bonne valeur (puisque la calcul aboutit normalement), mais que des qu'il s'agit d'affichage (console ou fichier) alors le comportement devient chaotique. Vous comprendrez que cet effet "magique" rend le debuggage assez complexe.
 
Un dernier détail :
J'ai déjà rencontré ce problème avec une autre variable, qui, comme "object_tot", est un tableau déclaré avec la taille "pop_size_max" (fixée par une déclaration de type PARAMETER), alors que sa taille "reelle" au cours du calcul est pop_size. Je l'avais alors résolu en veillant à initialiser cette variable à 0 jusqu'à pop_size_max, et non jusqu'à pop_size, ce qui était le cas avant. Mais la meme vérification appliquée à ma variable "object_tot" n'a pas eu ici le meme effet.
 
DONC : je m'adresse à vous afin de recueillir vos ipressions sur le sujet, et en particulier, savoir si l'un d'entre vous avait déjà rencontré ce phénomène.

UPDATE :
 
en continuant à trifouiller un peu mon code, je n'ai fait que découvrir des choses toujours plus étranges :
 
D'abord, je me suis rendu compte qu'en commentant l'appel à la sous-routine incriminée, le problème disparaissait, signe que "quelquechose" était louche avec celle-ci
 
Du coup, j'ai successivement commenté et décommenté certaines lignes de la sous-procédure en question, pour me rendre compte que seule une ligne de code semblait etre à l'origine du problème, puisqu'en commentant cell-ci , tout fonctionnait.
Problème : cette ligne de code NE FAIT PAS intervenir la variable "object_tot" (meme indirectement)
 
Alors j'ai fait des WRITE(*,*) de toutes les variables intervenant dans cette sous-procédure, mais alors je retrouvai l'effet "guérisseur" du WRITE mentionné dans mon premier post.
 
Finalement, je me suis rendu compte que ce que j'affichais sur la console avec WRITE N'AVAIT AUCUNE IMPORTANCE. Afficher juste la chaine ' ' (un espace, donc...) suffit à régler le problème. Du coup je me suis dit que le problème venait du nombre de lignes de codes exécutées (je sais c absurde, mais bon...) et j'ai remplacé ce write par une ligne de code "bidon" (style "a=2" ), juste pour avoir une ligne de code supplémentaire, mais les NaN réapparaissent.
Conclusion : il faut que ce soit un WRITE
 
Voila, j'ai hate que quelqu'un m'explique ce qu'il se passe, parce que la j'en perds mon latin.

Problème de description de format ?
Sinon, quel est ton compilateur ? Ça te fait la même chose avec un autre compilo ?

Et puis poste un peu le code d'écriture, notamment l'écriture

J'utilise gfortran et je n'ai pas d'autre compilateur pour tester. Tu me conseilles lequel qui soit facile à installer (je suis sous Ubuntu 8.10)?
 
Sinon, voici une tentative d'outline très simplifié de mon code, avec les endroits et les variables qui concerne mon problème :  

 
Donc ca c'est mon main (restreint aux instructions dont j'ai besoin pour mon exemple), ou la sous-routine kill_worst modifie new_obj_tot à partir des valeurs de old_obj_tot, n_best et n_worst, et la routine write_stat_object écrit des valeurs "statistiques" (type max,min et moyenne) issues de new_obj_tot.
 
kill_worst se présente comme ceci :  

 
(NB : le WRITE(99,*) est le fameux write "magique" qui fait disparaitre les NaN de mes fichiers)
 
Quand à WRITE_STAT_OBJECT :

 
D'avance merci.

Pour ma part, j'utilise indifféremment g95 ou gfortran.
Dans ta fonction d'écriture, t'as vérifié que les inputs étaient correctement lues ?
Sinon, je n'ai rien vu qui puisse faire apparaître un tel comportement (mais je ne suis pas expert fortran 77). Mais vérifie qu'il n'y a pas de problème d'interface (genre un double qui se transforme en real dans une fonction), c'est le genre de truc qui arrive quand tu mets à jour du vieux code.
 
Tu compiles avec des -W -Wall ? Sinon, fais-le

J'utilise pas fortran donc je peux pas aider, mais je tiens à indiquer que Fortran n'est absolument pas un langage fonctionnel, le topic ne devrait donc pas être dans cette sous-cat, mais dans Divers.

Masklinn > doléance notée. Je déplace ce topic.