Les opérateurs

Le langage Fortran définit quatre classes d’opérateurs : arithmétiques, relationnels, logiques et enfin spécifiques aux chaînes de caractères. Pour écrire des expressions correctes, il est indispensable de connaître les caractéristiques de chaque opérateur. Une de ces caractéristique est par exemple l’arité qui définit le nombre des opérandes d’un opérateur. On différencie, par exemple, l’expression -z qui utilise un opérateur unaire de l’expression x-y où l’on utilise un opérateur binaire. Mais les caractéristiques qui nous intéressent ici sont surtout :
l’associativité : l’associativité décrit l’ordre conventionnel d’évaluation des expressions. Les opérateurs arithmétiques sont en général associatifs à gauche ainsi l’expression x+y+z sera évaluée de gauche à droite comme (x+y)+z .
Une exception, l’opérateur élévation à la puissance noté ** en Fortran, est associatif à droite. L’expression x**y**zz sera évaluée de droite à gauche comme x**(y**z) ; la précédence : ou priorité relative. C’est encore une convention qui permet de déterminer quels sont les opérateurs utilisés en premier lors de l’évaluation d’une expression. Par exemple l’ opérateur multiplication * est traditionnellement prioritaire sur l’ opérateur addition + et l’expression x+y*z est évaluée comme x+(y*z) . Pour des opérateurs différents mais de même précédence, on utilise l’associativité, ainsi dans x/y*z , les opérateurs diviser ( / ) et multiplier ( * ) ont la même priorité mais sont associatifs à gauche on évalue donc cette dernière expression comme : (x/y)*z .

Opérateurs arithmétiques

Ces opérateurs s’appliquent aux types numériques (entiers, réels, complexes).
L’opérateur ** est l’ exponentiation.
Les priorités sont les suivantes, on applique :
1. ** puis
2. * , / et % et enfin
3. + et – unaires ou binaires.
Attention :
. l’opérateur ** est associatif à droite. x**y**z est évalué comme x**(y**z) ; . l’opérateur / appliqué à des variables de type integer est la division euclidienne ( 5/2 vaut 2 ) ;
. on considère généralement que les opérateurs unaires ont une plus forte priorité mais ce n’est pas le cas en Fortran.
Ainsi -1.0**2 vaut -1.0 , pour obtenir une puissance de -1 ,
il faudra écrire : (-1.0)**2 (qui ouf ! vaut bien 1.0 ).
Conseil méthodologique :
I éviter lorsque c’est possible d’utiliser l’opérateur **. La multiplication est plus précise et plus rapide :
…
c ………. ne pas ecrire
c y = x**2
cz = t**3
c ……….. mais plutot: y = x*x
z = t*t*t
De même, si l’on a besoin de la valeur x**i dans une boucle d’indice i, il faut mieux la calculer par récurrence :…
xi=1.0
do i=1, n
c …… xi vaut x**i, calcul par recurrence
xi=xi*x
…
enddo
…

Opérateurs relationnels

Ces opérateurs s’appliquent aux types numériques (entier, réels, complexes) et aux chaînes de caractères.
Les significations sont les suivantes :
– .lt. est l’opérateur inférieur (Less Than) ;
– .le. est l’opérateur inférieur ou égal (Less than or Equal) ;
– .eq. est l’opérateur égalité (EQual) ;
– .ne. est l’opérateur inégalité (Not Equal) ;
– .ge. est l’opérateur supérieur ou égal (Greater than or Equal) ;
– .gt. est l’opérateur supérieur (Greater Than).
Ces opérateurs ne peuvent être combinés pour former des expressions. Leur résultat est de type logical et prend donc l’une des valeurs .true. ou .false. .
Remarque :
) les opérateurs arithmétiques sont prioritaires sur les opérateurs relation-nels. Il est inutile de parenthéser l’expression x+y.gt.z**t sauf
pour la rendre plus lisible. . . (x+y).gt.(z**t) ce qui est souhai-table !.
Attention :
. l’application de ces opérateurs à des chaînes de caractères nécessite des précautions ! ! Si l’on applique l’opérateur égalité ou inégalité (.eq. ou .ne.) à des chaînes de longueur différentes on procède de la façon sui-vante :
1. On cherche la longueur «utile» de la chaîne la plus longue, c’est à dire en enlevant les blancs à droite.
2. Si cette longueur «utile» est supérieure strictement à la longueur de la chaîne la plus courte alors les deux chaînes sont forcement différentes.
3. Si cette longueur «utile» est inférieure ou égale à la longueur de la chaîne la plus courte la comparaison s’effectue sur la longueur «com-mune» des deux chaînes.
…
logical ok1, ok2, non3
character*2 ch
character*10 ch1, ch2, ch3
…
ch = ‘zz’
ch1 = ‘zz’
ch2 = ‘zz ‘
ch3 = ‘zzz’
ok1 = ch.eq.ch1
ok2 = ch.eq.ch2
non3 = ch.eq.ch3
…
Dans cet exemple ok1 et ok2, ont la valeur .true. , les longueurs utiles de ch1 et ch2 sont égales à la longueur de ch.
non3 a la valeur .false. , la longueur «utile» de ch3 est supérieure à celle de ch.
Le résultat des opérateurs de comparaison (.lt. , .le. , .ge. , .gt.) dépend en plus du codage interne des caractères donc de la machine utilisée. Pour écrire un code portable, il faut utiliser les fonctions de la bibliothèque standard Fortran : llt, lle, lge et lgt qui garantissent un résultat conforme au codage ASCII.
Un opérateur de comparaison (.lt. , .le. , .ge. , .gt.) appliqué à des chaînes de longueur différentes ne travaille que sur la partie «commune» des deux chaînes, il «tronque» donc la chaîne la plus longue. Si les parties
«communes» sont identiques, la chaîne qui a la plus grande partie «utile» est la plus grande.
…
logical ok1, ok2, ok3, non4
character*2 ch
character*10 ch1, ch2, ch3, ch4
…
ch =’bb’
ch1 =’zz’
ch2 =’zzzz ‘
ch3 =’bbzzzzz’
ch4 =’aaa’
ok1 = ch.lt.ch1
ok2 = ch.lt.ch2
ok3 = ch.lt.ch3
non4 = ch.lt.ch4
…
Dans cet exemple, ok1, ok2 et ok3 ont la même valeur ( .true. ), dans les deux premiers cas, la comparaison s’effectue sur la longueur «com-mune», dans le troisième cas, ch3 a une longueur «utile» supérieure. non4 à la valeur .false. car la comparaison s’effectue sur la longueur «commune».
Conseils méthodologiques :
I attention, comparer à zéro des valeurs réelles ou complexes (stockées en mode flottant) n’a pas forcément de sens ;
I attention aux chaînes de caractères, ne pas utiliser .lt. , .le. , .ge. et .gt. mais les fonctions de la bibliothèque standard Fortran llt, lle, lge et lgt ;
I ne pas utiliser ces opérateurs avec des variables de type logical. Il existe d’autres opérateurs pour tester l’égalité ou l’inégalité de variables booléennes.

Opérateurs logiques

Les opérateurs logiques permettent de manipuler des variables booléennes de type logical.
Les priorités sont les suivantes on applique :
1. .not. puis
2. .and. puis
3. .or et enfin
4. .eqv. et .neqv.
Ouf ! pour une fois l’opérateur unaire a bien la plus forte priorité. Mais Les noms des opérateurs rendent les expressions logiques parfois difficiles à déchiffrer. . .

1 Les données 
1.1 Identificateurs
1.2 Le type entier
1.3 Les types réels
1.4 Le type complexe
1.4.1 Quelques fonctions
1.5 Le type logique
1.6 Les chaînes de caractères
1.7 Déclarations
1.8 Déclarer des constantes
1.9 Le constructeur tableau
1.10 Initialisations
1.11 (pas de) data
2 Les opérateurs 
2.1 Opérateurs arithmétiques
2.2 Opérateurs relationnels
2.3 Opérateurs logiques
2.4 Opérateurs sur les chaînes de caractères
2.4.1 Sous-chaîne
3 Affectation et évaluation 
3.1 Les conversions implicites
3.2 Les conversions explicites
3.2.1 Changement de précision
4 Les programmes
4.1 Formattage
4.2 Fichiers à inclure
4.3 Quelques instructions
4.4 Les structures de contrôle
5 sous programmes
5.1 sous programme subroutine
5.2 sous programme function
5.3 Les arguments
5.4 Argument sous programme
5.5 Fonction «en ligne»
6 Plus sur les Variables
6.1 Variables partagées : le common
6.2 (pas de) block data
6.3 Rémanence : save
6.4 Le super-tableau
6.5 Synonymes : (pas d’) equivalence
7 Les entrées/Sorties 
7.1 Unités logiques, physiques
7.2 Écran-clavier
7.3 Entrées-Sorties sur fichiers
7.4 Informations, l’instruction inquire
7.5 read et write : entrées/Sorties «formattées»
7.6 read et write : entrées/Sorties «binaires»
7.7 read et write : l’accès direct
7.8 gestion du «pointeur de fichier»
7.9 Des exemples
8 Les fonctions standards 
8.1 Conversions
8.2 Manipulations variées
8.3 Fonctions mathématiques
8.4 chaînes de caractères
8.5 Les noms spécifiques
A Précédence et associativité 
B Liste des mots-clef