Discussion :

[Jayceblaster]

Bonjour...
Je connais pas le Fortran mais je dois migrer un programme qui contient du fortran 77 en fortran 90.
J'ai par exemple:

Code :

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

1
2
3
4
5
 
int toto;
:
:
toto = .TRUE.

et lorsque que je debug mon programme j'ai toto = -1. Est ce normal? je m'attend a avoir du toto = 1.
surtout que par la suite j'ai

Code :

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

1
2
 
if (toto .EQ. 1) THEN

forcement la condition n'est pas satisfaite parce que toto = -1.
Quelqu'un saurait il m'expliquer et me dire comment remedier a cela? (car j'ai ce type d'erreur qui apparait a diverse endroit de mon programme-> et cela marché dans le programme de base en fortran 77).

Merci d'avance...

PS: je travaille sous visual studio 2008....si ca peut aider...

[Sylvain Bergeron]

(En résumant)

Je dois migrer un programme qui contient du fortran 77 en fortran 90.
J'ai par exemple:

Code :

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

1
2
3
4
 
int toto;
:
toto = .TRUE.

et lorsque que je debug mon programme j'ai toto = -1. Est ce normal? je m'attend a avoir du toto = 1.
surtout que par la suite j'ai

Code :

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

1
2
 
if (toto .EQ. 1) THEN

La principale raison pour laquelle ça ne fonctionne pas, c'est que le code est illégal. Tu n'as pas le droit d'assigner un logique à un entier, et tu n'as pas plus le droit d'extraire la « valeur numérique » d'un logique. Il n'y a pas de correspondance logique <--> numérique. Le standard Fortran spécifie qu'une variable logique peut avoir 2 états : vrai ou faux. Il ne spécifie pas ce que vaut vrai numériquement, ni ce que vaut faux.

Certains compilateurs, surtout les plus anciens, utilisent la représentation binaire 0...00001 (=1) pour vrai et 0...00000 (=0) pour faux alors que d'autres compilateurs, surtout les plus récents, utilisent 1...111111 (=-1) et 0...00000 respectivement. Lorsque tu teste la valeur numérique d'un logique, le programme devient non portable et de gros ennuis surviennent si tu change de compilateur...

Les solutions que je vois :

• Utiliser des vrais logiques « mur à mur » (logical Toto; Toto = .true.; if (Toto) then;...)
• Te définir des constantes entières Vrai (ou True) et Faux (ou False) valant 1 et 0, et remplacer les = .true. par = True

La première solution est nettement plus robuste. La deuxième ne fonctionne pas si l'entier est assigné par une expression logique (ex: Toto = a .LT. b), mais selon le contexte, elle peut exiger moins de modifications...

Une dernière mise en garde. On ne doit jamais faire (à moins de savoir exactement ce que l'on fait) :

Code :

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

1
2
3
4
5
 
logical Toto
...
Toto = ...
if (Toto .eq. .true.) ...

Le « Toto .eq. .true. » est une opération « bitwise » (et n'est de toute façon pas standard). Ça ne teste pas si Toto est vrai, mais si chaque bit de Toto est égal à la bit correspondante de .true. Il est de loin préférable de simplement faire « if (Toto) ... »

[Sylvain Bergeron]

Un dernier commentaire :

... je dois migrer un programme qui contient du fortran 77 en fortran 90...

Il ne faut pas confondre moderniser et migrer.

Le Fortran 77 est un sous-ensemble de Fortran 90 (il y a bien quelques trucs qui sont disparus, mais les compilateurs continuent à les supporter). Un programme F77 est donc, par définition, un programme F90. On ne peut donc pas migrer... On peut le moderniser, ajouter des allocates, passer en format libre, ajouter des modules, qui le rendront incompatible à Fortran 77, mais ça ne change pas le fait que le programme était déjà en F90...

Tes problèmes de migration, ce ne sont pas des problèmes de migration de F77 à F90, mais des problèmes de migration d'un programme non standard (donc non portable) d'un compilateur à un autre...

[Ehouarn]

Bojour,

Pour compléter les très bonnes explications ci-dessus, en fortran le test d'équivalence entre deux éléments de type logiques est .eqv. (et son complément .neqv. teste la différence, c.-à-d. fait office de "ou exclusif").

Code :

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

1
2
3
4
5
 
logical Toto
...
Toto = ...
if (Toto .eqv. .true.) ...

[FR119492]

Salut!
Le Fortran possède une instruction EQUIVALENCE que les informaticiens "modernes" considèrent en général comme une hérésie, mais qui est parfois bien utile. Elle permet d'utiliser les mêmes octets en mémoire pour des variables distinctes, souvent de types différents. Voici le code d'un petit programme que j'avais écrit pour montrer la représentation binaire d'un nombre réel et qui utilise cette instruction.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
C
C **********************************************************************
C
      Subroutine AS0121    
C
C     Représentation d'une variable de type Real*4
C
C **********************************************************************
C
C     Déclarations
C
      Implicit None
C
      Character*80 S
      Real*4 R,Ra,Rb
	Integer*1 I1(4),I1a(4),I1b(4),K
	Equivalence (I1,R),(I1a,Ra),(I1b,Rb)
C
C **********************************************************************
C
C     Instructions exécutables
C
      Open (4,File='AS0121.txt')
   10 Write (*,*) ' '
      S='Tapez le numérateur'
	Call U003(S,Len_Trim(S))
	S='(Ctrl-Z pour quitter)'
	Call U003(S,Len_Trim(S))
	Read (*,*,End=99,Err=20) Ra
	Go To 30
C
   20	S='Donnée incorrecte'
      Call U003(S,Len_Trim(S))
	Go To 10
C
   30 S='Tapez le dénominateur'
	Call U003(S,Len_Trim(S))
	Read (*,*,End=99,Err=40) Rb
	Go To 50
C
   40	S='Donnée incorrecte'
      Call U003(S,Len_Trim(S))
	Go To 30
C
   50 R=Ra/Rb
      Write (*,'(//2F8.3,E16.9)') Ra,Rb,R
      Write (*,'(/1X,A)') 'Adr+3    Adr+2    Adr+1    Adr'
      Write (*,'(4(1X,8I1))')
     *  (-BTest(I1(4),K),K=7,0,-1),(-BTest(I1(3),K),K=7,0,-1),
     *  (-BTest(I1(2),K),K=7,0,-1),(-BTest(I1(1),K),K=7,0,-1)
C
      Write (4,'(//2F8.3,E16.9)') Ra,Rb,R
      Write (4,'(/1X,A)') 'Adr+3    Adr+2    Adr+1    Adr'
      Write (4,'(4(1X,8I1))')
     *  (-BTest(I1(4),K),K=7,0,-1),(-BTest(I1(3),K),K=7,0,-1),
     *  (-BTest(I1(2),K),K=7,0,-1),(-BTest(I1(1),K),K=7,0,-1)
	Go To 10
C
   99 Close (4)
      Return
      End

Jean-Marc Blanc