langage FORTAN
Introduction
Historique
bibliographie
documentation
2 Généralités
3 Déclarations
4 Opérateurs et expressions
5 Structures de contrôle
6 Tableaux
7 Entrées-Sorties
8 Procédures
9 Common
10 Include
Code machine (notation numérique en octal) ;
Assembleurs de codes mnémoniques ;
1954 : projet création du premier langage
symbolique FORTRAN par John Backus d’IBM (Mathematical FORmula
TRANslating System) :
Efficacité du code généré (performance) ;
Langage quasi naturel pour scientifiques (productivité, maintenance, lisibilité).
1957 : Livraison des premiers compilateurs ;
1958 : Fortran II (IBM) )sous-programmes compilables de façon indépendante.
Généralisation aux autres constructeurs mais :
divergences des extensions )nécessité de normalisation ;
ASA American Standards Association (ANSI American Nat. Standards Institute).
Comité chargé du développement d’une norme Fortran.
1966 : Fortran IV (Fortran 66) ;
Évolution par extensions divergentes. . .
1977 : Fortran V (Fortran 77).
quasi compatible :
aucune itération des boucles nulles (DO I=1,0)
Nouveautés principales :
type caractère ;
IF-THEN-ELSE ;
E/S accès direct et OPEN.
Travail des comités X3J3/ANSI et WG5/ISO pour moderniser Fortran 77 :
Standardisation : inclusion d’extensions ;
Développement : nouveaux concepts déjà exploités par langages plus récents APL,
Algol, PASCAL, Ada ; . . .
Performances en calcul scientifique ;
Totalement compatible avec Fortran 77.
1991/1992 : Norme Fortran 90 (ISO et ANSI) ;
1994 : Premiers compilateurs Fortran 90 Cray et IBM ;
1997 : Norme Fortran 95 (ISO et ANSI) ;
1999 : Premiers compilateurs Fortran 95 sur Cray T3E puis IBM RS/6000 ;
septembre 2004 : Norme Fortran 2003 (ISO et ANSI) ;
octobre 2010 : Norme Fortran 2008 (ISO et ANSI).
Adams, Brainerd, Hendrickson, Maine, Martin, Smith, The Fortran 2003
Handbook, Springer, 2009, (712 pages), ISBN 978-1-84628-378-9 ;
Adams, Brainerd, Martin, Smith et Wagener, Fortran 95 Handbook, MIT Press,
1997, (711 pages), ISBN 0-262-51096-0 ;
Brainerd, Goldberg, Adams, Programmer’s guide to Fortran 90, 3e édit. Unicomp,
1996, (408 pages), ISBN 0-07-000248-7 ;
Arjen Markus, Modern Fortran in Practice, Cambridge University Press,
juin 2012, (272 pages), ISBN 978-1-10760-347-9 ;
Chamberland Luc, Fortran 90 : A Reference Guide, Prentice Hall,
ISBN 0-13-397332-8 ;
Delannoy Claude, Programmer en Fortran 90 – Guide complet, Eyrolles, 1997,
(413 pages), ISBN 2-212-08982-1 ;
Dubesset M., Vignes J., Les spécificités du Fortran 90, Éditions Technip, 1993,
(400 pages), ISBN 2-7108-0652-5 ;
Ellis, Phillips, Lahey, Fortran 90 Programming, Addisson-Wesley, 1994,
(825 pages), ISBN 0-201-54446-6 ;
Hahn B.D., Fortran 90 for the Scientist & Engineers, Edward Arnold, London,
1994, (360 pages), ISBN 0-340-60034-9 ;
Kerrigan James F., Migrating to Fortran 90, O’Reilly & Associates Inc.,
1994, (389 pages), ISBN 1-56592-049-X ;
Lignelet P., Fortran 90 : approche par la pratique, Éditions Studio Image
(série informatique), 1993, ISBN 2-909615-01-4 ;
Lignelet P., Manuel complet du langage Fortran 90 et Fortran 95, calcul intensif
et génie logiciel, Col. Mesures physiques,Masson, 1996, (320 pages),
ISBN 2-225-85229-4 ;
Lignelet P., Structures de données et leurs algorithmes avec Fortran 90 et
Fortran 95, Masson, 1996, (360 pages), ISBN 2-225-85373-8 ;
Morgan and Schoenfelder, Programming in Fortran 90, Alfred Waller Ltd., 1993,
ISBN 1-872474-06-3 ;
Metcalf M., Reid J.,
Fortran 90 explained, Science Publications, Oxford, 1994, (294 pages),
ISBN 0-19-853772-7, Traduction française par Pichon B. et Caillat M.,
Fortran 90 : les concepts fondamentaux, Éditions AFNOR, 1993, ISBN
2-12-486513-7 ;
Fortran 90/95 explained, Oxford University Press, 1996, (345 pages),
ISBN 0-19-851888-9 ;
Fortran 95/2003 explained, Oxford University Press, 2004, (416 pages),
ISBN 0-19-852693-8 ;
Olagnon Michel, Traitement de données numériques avec Fortran 90,
Masson, 1996, (364 pages), ISBN 2-225-85259-6 ;
Redwine Cooper, Upgrading to Fortran 90,
Springer, 1995, ISBN 0-387-97995-6 ;
International Standard ISO/IEC 1539-1:1997(E) Information technology - Progr.
languages - Fortran - Part1 : Base language. Disponible auprès de l’AFNOR.
1 Introduction
2 Généralités
Bases de numération
Représentation des données
Représentation des entiers
Représentation des réels
Représentation des complexes
Représentation des logiques
Représentation des caractères
Jeu de caractères
Notion d’unité de programme
Éléments syntaxiques
Format libre
Commentaires
3 Déclarations
4 Opérateurs et expressions
5 Structures de contrôle
6 Tableaux
7 Entrées-Sorties
8 Procédures
9 Common
10 Include
L’écriture d’un nombre en octal s’effectuera à l’aide des chiffres de 0 à 7.
L’écriture d’un nombre en hexadécimal s’effectuera à l’aide des chiffres de 0 à 9 auxquels
on ajoute les lettres de a à f.
Supposons que l’on dispose de l’écriture d’un nombre en base 2. Sa
conversion en octal
peut être faite en découpant le motif binaire par tranches de 3 bits en partant de la
droite, puis en convertissant en base 10 chaque groupe obtenu.
Sa conversion en hexadécimal pourra s’effectuer de la même manière à l’aide d’un
découpage par tranches de 4 bits.
Exemple
10011101012 = 1 20 + 1*22 + 1*24 + 1*25 + 1*26 + 1*29
= 62910
1001110101^2 = 1|001|110|1012 = 1165^8
1001110101^2 = 10|0111|01012 = 275^16
Représentation des entiers
Dans la mémoire de l’ordinateur, les données numériques sont représentées à l’aide d’un
motif binaire de longueur 32, 64 voire 128 bits.
La représentation en machine d’un nombre entier positif correspond à son écriture en
base 2. Pour l’obtenir, il suffit de procéder à des divisions successives par 2.
Les nombres entiers négatifs sont représentés en complément vrai ou complément à 2
qui consiste, à partir du motif binaire du nombre positif, à inverser tous les bits puis
d’ajouter 1.
De ce fait, sur n bits, les nombres représentables sont les suivants :
-2^n-1 <i < 2^n-1 - 1
Exemple
+510 = 000000000000000000000000000001012
-510 = 111111111111111111111111111110102 + 1
-510 = 111111111111111111111111111110112
-510 = FFFFFFFB16
Représentation des réels
Un nombre réel ou flottant est caractérisé par :
1 son signe ;
2 son exposant ou caractéristique ;
3 sa mantisse.
Son mode de représentation est un motif binaire respectant la norme IEEE.
Représentation d’un nombre réel sur 32 bits
Ce type de réel, appelé réel simple précision, admet un motif binaire de la forme :
seeeeeeeem—–m
avec :
s : bit de signe ;
e : exposant sur 8 bits à excédent 127 ;
m : mantisse sur 23 bits.
Le nombre représenté correspond à ) r = s1.m × 2^e-127
Ce type de représentation permet de représenter les nombres :
1.2×10^-38 < |r| <3.4×10^+38
avec 6 chiffres significatifs.
Représentation d’un nombre réel sur 64 bits
Ce type de réel, appelé réel double précision, admet un motif binaire de la
forme :
seeeeeeeeeeem—–m
avec :
s : bit de signe,
e : exposant sur 11 bits à excédent 1023,
m : mantisse sur 52 bits.
Le nombre représenté correspond à ) r = s1.m × 2e-1023
Ce type de représentation permet de représenter les nombres :
2.2×10^-308 < |r| <1.8×10^+308
avec 15 chiffres significatifs.
Représentation du réel 10,4 sur 32 bits
On peut écrire ce réel sous la forme suivante :
10,4 =104/10=25/5=110100^2/101^2
Représentation des caractères
Un caractère est codé sur 1 octet. Sa représentation interne respecte un
codage appelé
codage ASCII.
Il existe 128 caractères différents dont les représentations sont indiquées
dans une table
dite table ASCII.
Dans cette table les caractères numériques ainsi que les caractères
alphabétiques
(majuscules et minuscules) sont rangés consécutivement et en ordre
croissant.
On appelle chaîne de caractères une suite de caractères rangés de façon
consécutive en
mémoire.
Jeu de caractères
26 lettres de l’alphabet ;
chiffres 0 à 9 ;
caractères spéciaux :
! * + " <
( = > ) ;
% / - : ,
? ’ . & $
le caractère espace ;
le caractère _ (underscore).
Remarque :
les caractères minuscules sont convertis en majuscules par le compilateur
Un programme source Fortran est composé de parties indépendantes
appelées unités de
programme (scoping unit).
Chaque partie est compilée de façon indépendante. Chacune admet son
propre
environnement. Il sera cependant possible que ces parties communiquent
entre elles.
Les différentes unités de programme sont :
1 le programme principal ;
2 les sous-programmes :
de type subroutine ;
de type function.
3 les modules ;
4 les block data.
Chaque unité comprend une partie déclarative (déclaration des variables locales, ...) suivie
d’une partie comportant des instructions exécutables parmi lesquelles peut apparaître
l’instruction STOP qui provoque l’interruption du programme.
Éléments syntaxiques
Dans le mode « format libre »les lignes peuvent être de longueur quelconque à
concurrence de 132 caractères.
Il est également possible de coder plusieurs instructions sur une même ligne en les
séparant avec le caractère « ; ».
Exemple
print *, " Entrez une valeur :"; read *,n
Une instruction peut être codée sur plusieurs lignes : on utilisera alors le caractère « & ».
Exemple
print *, " Montant HT :", montant_ht , &
" TVA :", tva ,&
" Montant TTC :", montant_ttc
Lors de la coupure d’une chaîne de caractères la suite de la chaîne doit
obligatoirement
être précédée du caractère « & ».
Exemple
print *, " Entrez un nombre entier &
& compris entre 100 & 199 "
Remarque : il existe aussi le « Format fixe », considéré maintenant comme
obsolète dont
la structure d’une ligne est :
1 zone étiquette (colonnes 1 à 5) ;
2 zone instruction (colonnes 7 à 72) ;
3 colonne suite (colonne 6)
Le caractère « ! »rencontré sur une ligne indique que ce qui suit est un commentaire. On
peut évidemment écrire une ligne complète de commentaires : il suffit pour cela que le 1er
caractère non blanc soit le caractère « ! ».
Exemple
if (n < 100 .or. n > 199) ! Test cas d’ erreur
. . . .
! On lit l’ exposant
read *,x
! On lit la base
read *,y
if (y <= 0) then ! Test cas d’ erreur
print *," La base doit être un nombre > 0"
else
z = y**x ! On calcule la puissance
end if
Remarque :
En format fixe, les lignes qui commencent par C, c, * ou ! en colonne 1 sont des commentaires.
1 Introduction
2 Généralités
3 Déclarations
Identificateurs
Différents types
Syntaxe
Le type CHARACTER
Instruction IMPLICIT NONE
Constantes littérales
Constantes entières
Constantes réelles simple précision
Constantes réelles double précision
Constantes complexes
Constantes chaînes de caractères
Initialisation
L’instruction DATA
Le symbole " = "
Constantes symboliques
Instruction EQUIVALENCE
4 Opérateurs et expressions
5 Structures de contrôle
Un identificateur permet de donner un nom à :
une variable ;
une constante ;
une procédure.
Il est défini par :
une suite de caractères alphanumériques (lettres non accentuées, chiffres,
underscore) ;
le premier caractère doit être une lettre ;
la longueur est limitée à 31 caractères ;
on ne distingue pas les lettres majuscules des minuscules.
Exemple
compteur
Compteur
fin_de_fichier
montant_annee_1993
Déclarations Différents types
Le type d’une variable détermine :
le nombre d’octets à réserver en mémoire ;
un mode de représentation interne ;
l’ensemble des valeurs admissibles ;
l’ensemble des opérateurs qui peuvent lui être appliqués.
Types prédéfinis
Mot clé. Type
INTEGER : entier
CHARACTER : caractère
LOGICAL : deux valeurs .TRUE., .FALSE.
REAL : réel simple précision
DOUBLE PRECISION : réel double précision
COMPLEX : complexe simple précision
Remarque :
la précision d’un réel simple est de 7 chiffres décimaux significatifs alors que celle d’un
Attributs
Chaque type peut être surchargé d’attributs dont voici un extrait :
Attributs
Attribut Signification
PARAMETER : constante symbolique
DIMENSION : taille d’un tableau
SAVE : objet statique
EXTERNAL : procédure externe
Syntaxe d’une déclaration :
type[, liste_attributs ::] liste_identificateurs
Exemple
PROGRAM declaration
INTEGER , SAVE :: compteur
INTEGER :: temperature
LOGICAL :: arret_boucle
...
END PROGRAM declaration
...
PROGRAM declaration
INTEGER indice_boucle
SAVE indice_boucle
...
END PROGRAM declaration
Pour déclarer une chaîne de caractères on précise de plus sa longueur. Si elle n’est pas
indiquée elle est égale à 1 :
CHARACTER(len=n) ch_car
CHARACTER c
L’ancienne syntaxe suivante est toujours disponible mais déclarée obsolète :
CHARACTER*n ch_car
Exemple
PROGRAM declaration
CHARACTER ( LEN =11) chaine1
CHARACTER *11 chaine2
...
END PROGRAM declaration
Par défaut, les variables dont l’identificateur commence par les caractères I à N sont de
type INTEGER.
Toutes les autres sont de type REAL.
L’instruction IMPLICIT NONE change cette règle car elle impose à l’utilisateur la
déclaration de chaque variable.
Cette instruction est vivement recommandée car elle permet la détection d’un certain
nombre d’erreurs à la compilation.
IMPLICIT NONE se place avant les déclarations des variables,
L’instruction ne s’applique qu’à l’unité de programme qui la contient.
une suite de chiffres en base 10,
une suite de chiffres en base 2 encadrée par des quotes, le tout précédé du caractère
B,
une suite de chiffres en base 8 encadrée par des quotes, le tout précédé du caractère
O,
une suite de chiffres en base 16 encadrée par des quotes, le tout précédé du
caractère Z.
Une valeur négative sera précédée du signe -.
Exemple
1
123
-28
B’ 11011011100 ’
O’3334 ’
Z’6DC ’
Remarque :
Les constantes écrites en base 2, 8 ou 16 s’appellent des constantes BOZ. Elles ne peuvent
figurer que dans les instructions d’initialisation de type DATA.
Une constante de type REAL doit obligatoirement comporter :
soit le point décimal, même s’il n’y a pas de chiffres après la virgule ;
soit le caractère E pour la notation en virgule flottante.
Pour les nombres écrits 0.xxxxx, on peut omettre le 0 avant le point décimal.
Exemple
0.
1.0
1.
3.1415
31415E -4
1.6E -19
1 E12
.001
-36.
Une constante double precision doit obligatoirement être écrite en virgule flottante, le E
étant remplacé par un D.
Exemple
0D0
0. D0
1. D0
1d0
3.1415 d0
31415d -4
1.6D -19
1 d12
-36. d0
Une constante de type COMPLEX est obtenue en combinant deux constantes réelles entre
parenthèses séparées par une virgule : 2.5+i s’écrira (2.5,1.)
Exemple
(0. ,0.)
(1. , -1.)
(1.34e -7, 4.89e -8)
INTRINSIC : procédure intrinsèque
double est de 15.
Une constante chaînes de caractères est une suite de caractères encadrée par le délimiteur
« ’ » ou bien « " ».
Si parmi la suite des caractères figure le caractère délimiteur, il devra être doublé.
Exemple
’La somme des n premiers entiers est : ’
’l’’étendue désirée est : ’
"l’ étendue désirée est : "
À partir d’une variable chaîne de caractères on peut extraire une suite de caractères
contigus. Pour cela on spécifie le nom de la variable suivi entre parenthèses d’un couple
d’entiers « n:m » indiquant les rangs de début et de fin d’extraction.
Exemple
CHARACTER ( LEN =10) :: ch
ch = " Bonjour "; ch (4:7) = " soir "
Une initialisation pourra s’effectuer au moyen de l’instruction suivante :
DATA liste1/init1/[, ..., listei/initi/, ...]
listei fait référence à une liste de variables à initialiser,
initi indique les valeurs d’initialisation,
le type des valeurs d’initialisation doit respecter les règles suivantes :
pour un objet de type caractère ou logique, la constante d’initialisation doit être de
même type,
pour un objet de type
Exemple
REAL a, b, c
INTEGER n, m
LOGICAL arret
DATA a, b, n/1.0 , 2.0 , 17/
DATA c /2.6/ , m/3/
DATA arret /. FALSE ./
Remarques :
cette instruction peut apparaître après des instructions exécutables, mais la norme
F95 a déclaré cette possibilité comme obsolète ;
les variables initialisées par ce moyen héritent de l’attribut SAVE : elles sont alors
permanentes (cf. chapitre Procédures, section Durée de vie des
identificateurs).
Il n’est pas rare de trouver ce type d’initialisation lors de la déclaration comme dans
l’exemple suivant (ce n’est pas conseillé car cela ne fait pas partie de la norme donc non
portable) :
Extension
REAL a /3.14/ , b /2.718/
INTEGER n/1/ , m /4/
LOGICAL arret /. false ./
Fortran permet d’initialiser une variable lors de sa déclaration à l’aide du symbole « = ».
Dans ce contexte, les caractères « :: » sont obligatoires :
TYPE[, attributs] :: v1=c1[, ..., vi=ci, ...]
où vi est le nom de la variable à initialiser et ci sa valeur.
Exemple
PROGRAM initialisation
INTEGER :: debut = 100
REAL :: valeur = 76.3
LOGICAL :: drapeau = . TRUE .
...
END PROGRAM initialisation
Note : ces variables héritent alors de l’attribut SAVE, ce qui implique que leur
emplacement mémoire est permanent. Pour plus de détails, se reporter page 237 du
support.
L’attribut PARAMETER permet de donner un nom symbolique à une constante littérale :
TYPE, PARAMETER :: n1=c1[, ..., ni=ci, ...]
où ni est le nom donné à une constante et ci sa valeur.
La notation suivante est aussi utilisable :
PARAMETER ( n1=c1[, ..., ni=ci, ...] )
Exemple
PROGRAM constante
LOGICAL , PARAMETER :: VRAI =. TRUE ., FAUX =. FALSE .
DOUBLE PRECISION :: PI , RTOD
PARAMETER (PI =3.14159265 d0 , RTOD =180. d0/PI)
...
END PROGRAM constante
L’instruction EQUIVALENCE permet à des variables de partager la même zone
mémoire au sein d’une unité de programme ;
il n’y a pas de conversion de type ;
chaque variable garde les propriétés de son type ;
le type CHARACTER ne peut pas être associé à d’autres types.
Syntaxe générale :
EQUIVALENCE(v1, v2)[,..., (vi-1, vi),...]
où les vi sont des scalaires (variables simples ou éléments de tableaux).
Exemple
PROGRAM correspondance
COMPLEX cmplx (2)
REAL temp (4)
EQUIVALENCE ( temp (1) , cmplx (1))
...
END PROGRAM correspondance
Agencement en mémoire :
|--------cmplx(1)-------|--------cmplx(2)-------|
|-----------|-----------|-----------|-----------|
|--temp(1)--|--temp(2)--|--temp(3)--|--temp(4)--|
Exemple
PROGRAM correspondance
CHARACTER ( LEN =4) :: A, B
CHARACTER ( LEN =3) :: C (2)
CHARACTER ( LEN =10) :: chaine
CHARACTER ( LEN =1) , DIMENSION (10) :: tab_car
EQUIVALENCE (A,C (1)) ,(B,C (2))
EQUIVALENCE (chaine , tab_car (1))
...
END PROGRAM correspondance
Agencement en mémoire :
| 01 | 02 | 03 | 04 | 05 | 06 | 07 |
|---------A---------|
|-----C(1)-----|-----C(2)-----|
|---------B---------|
| 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 |
|-------------------- chaine ---------------------|
| |
|--> tab_car(1) |--> tab_car(7)
1 Introduction
2 Généralités
3 Déclarations
4 Opérateurs et expressions
Opérateurs arithmétiques
Les opérateurs
Conversion implicite
Opérateurs relationnels
Opérateurs logiques
Les tables de vérité
Opérateur de concaténation
Opérateur d’affectation
syntaxe générale
Règles de typage
Règles de typage
Règles de typage
Règles de typage
Règles de typage
Priorité des Opérateurs
5 Structures de contrôle
Les opérateurs
Table 3: Opérateurs arithmétiques
Symbole Expression Interprétation
+ o1 + o2 ajoute o2 à o1
+ + o1 égal à o1
- o1 - o2 soustrait o2 à o1
- - o1 inverse le signe de o1
* o1 * o2 multiplie o1 par o2
/ o1 / o2 o1 divisé par o2
** o1**o2 élève o1 à la puissance o2
Les opérandes o1 et o2 peuvent être :
une constante numérique ;
une variable numérique, précédée ou non d’un opérateur unaire (+ ou -) ;
Exemple
3.14159
K(
A + B) * (C + D)
-1.0 / X + Y / Z ** 2
-2.0 * 3.14159 * RADIUS
Le type d’une expression arithmétique dépend des types de ses opérandes.
Dans le cas d’opérateurs binaires :
1 si les 2 opérandes sont du même type alors l’expression arithmétique résultante sera
de ce type.
2 si les deux opérandes ne sont pas du même type alors l’expression arithmétique sera
évaluée dans le type le plus fort relativement à la hiérarchie suivante :
INTEGER < REAL < DOUBLE PRECISION < COMPLEX
une expression arithmétique entre parenthèses.
Le type d’une expression arithmétique dépend des types de ses opérandes.
Dans le cas d’opérateurs binaires :
1 si les 2 opérandes sont du même type alors l’expression arithmétique résultante sera
de ce type.
2 si les deux opérandes ne sont pas du même type alors l’expression arithmétique sera
évaluée dans le type le plus fort relativement à la hiérarchie suivante :
INTEGER < REAL < DOUBLE PRECISION < COMPLEX
Expression Valeur Type du résultat
99/100 0 INTEGER
7/3
(100*9)/5
(9/5)*100
99./100
99./100d0
(1.,2.)+1
Le type d’une expression arithmétique dépend des types de ses opérandes.
Dans le cas d’opérateurs binaires :
1 si les 2 opérandes sont du même type alors l’expression arithmétique résultante sera
de ce type.
2 si les deux opérandes ne sont pas du même type alors l’expression arithmétique sera
évaluée dans le type le plus fort relativement à la hiérarchie suivante :
INTEGER < REAL < DOUBLE PRECISION < COMPLEX
Expression Valeur Type du résultat
99/100 0 INTEGER
7/3 2
(100*9)/5
(9/5)*100
99./100
99./100d0
(1.,2.)+1
Le type d’une expression arithmétique dépend des types de ses opérandes.
Dans le cas d’opérateurs binaires :
1 si les 2 opérandes sont du même type alors l’expression arithmétique résultante sera
de ce type.
2 si les deux opérandes ne sont pas du même type alors l’expression arithmétique sera
évaluée dans le type le plus fort relativement à la hiérarchie suivante :
INTEGER < REAL < DOUBLE PRECISION < COMPLEX
Expression Valeur Type du résultat
99/100 0 INTEGER
7/3 2 INTEGER
(100*9)/5 180 INTEGER
(9/5)*100 100 INTEGER
99./100 0.99 REAL
99./100d0 0.99d0 DOUBLE PRECISION
(1.,2.)+1 (2.,2.) COMPLEX
Attention
Soit l’expression d = 1.d0+5.**0.5 avec la variable d déclarée en DOUBLE PRECISION.
La sous-expression 5.**0.5 est évaluée dans le type REAL car les opérandes de
l’opérateur ** le sont. Le reste de l’évaluation s’effectuera ensuite dans le type DOUBLE
PRECISION, le résultat étant finalement stocké dans la variable d.
Mais cette variable d bien que du type DOUBLE PRECISION hérite d’un calcul qui a
commencé dans le type REAL, d’où une perte de précision.
Cela peut induire par la suite des comportements inattendus lors de l’évaluation
d’expressions dans lesquelles figurent cette variable (problème de convergence dans des
processus itératifs comme dans l’exercice 3).
En conclusion, lors de l’écriture d’expressions avec présence de constantes réelles que l’on
désire évaluer en DOUBLE PRECISION, il est impératif d’écrire ces constantes dans ce
type. Ce qui donne pour l’expression précédente :
d = 1.d0+5.d0**0.5d0
Table 4: Opérateurs relationnels
Opérateur Opération
.LT. ou < strictement plus petit
.LE. ou <= inférieur ou égal
.EQ. ou == égal
.NE. ou /= non égal
.GT. ou > strictement plus grand
.GE. ou >= supérieur ou égal
Ces opérateurs admettent des opérandes de type INTEGER, REAL ou CHARACTER. Seuls les
opérateurs ==, /= peuvent s’appliquer à des expressions de type COMPLEX.
Exemple
N .GE. 0
X .LT. Y
Z /= 3.7
Les opérandes des opérateurs logiques doivent être des expressions de type LOGICAL.
Table 5: Opérateurs logiques
Opérateur Opération
.NOT. négation logique
.AND. conjonction logique
.OR. disjonction inclusive
.EQV. équivalence logique
.NEQV. non-équivalence logique
Table 6: Opérateur de négation
l .NOT.l
.true. .false.
.false. .true.
Table 7: Autres opérateurs
l1 l2 l1.AND.l2 l1.OR.l2 l1.EQV.l2 l1.NEQV.l2
.true. .true. .true. .true. .true. .false.
.true. .false. .false. .true. .false. .true.
.false. .true. .false. .true. .false. .true.
L’opérateur de concaténation n’admet que des expressions de type CHARACTER.
Expression Interprétation
c1 // c2 concatène c1 avec c2
Exemple
CHARACTER ( LEN =10) :: ch
ch = " BON " // " JOUR " ! <-- Affectation de la chaîne " BONJOUR "
ch = " BON "
ch = ch // " JOUR " ! <-- Inopérant !!!
ch = TRIM (ch) // " JOUR " ! <-- OK
Remarques :
1 lorsque la chaîne réceptrice est plus grande que celle affectée, elle est complétée à
l’aide du caractère espace ;
2 reportez-vous à la page 283 pour plus d’informations concernant la procédure TRIM
utilisée dans l’exemple ci-dessus.
variable = expression
où expression est une expression arithmétique, logique ou relationnelle.
une valeur de type CHARACTER ne peut pas être affectée à une variable numérique ou
vice-versa,
une valeur de type INTEGER peut être affectée à une variable de type REAL,
une valeur de type REAL peut également être affectée à une variable de type
INTEGER. Mais dans ce cas, la valeur est alors tronquée en supprimant la partie
fractionnaire.
En supposant dans les expressions suivantes, les variables x de type REAL et
n, m de type INTEGER :
Expression Interprétation
x = 5 x = 5.0
n = 0.9999 n = 0
m = -1.9999 m = -1
Table 8: Ordre de priorité des opérateurs
Opérateur Associativité
** D ! G
* et / G ! D
+ et - G ! D
// G ! D
<, <=, == G ! D
/=, >, >=
.NOT. ///////
.AND. G ! D
.OR. G ! D
.EQV. et .NEQV. G ! D
Opérateurs et expressions Priorité des Opérateurs
Table 8: Ordre de priorité des opérateurs
Opérateur Associativité
** D ! G
* et / G ! D
+ et - G ! D
// G ! D
<, <=, == G ! D
/=, >, >=
.NOT. ///////
.AND. G ! D
.OR. G ! D
.EQV. et .NEQV. G ! D
En supposant dans les expressions suivantes, les variables a, b, c, d de type REEL et
e, f, g de type LOGICAL :
Expression Interprétation
2**3**2 2**(3**2) = 512
5.+4.*9.**2 5.+(4.*(9.**2)) = 329.
e.OR.f.AND.g e.OR.(f.AND.g)
a**b+c.GT.d.AND.e (((a**b)+c).GT.d).AND.e
.false. .false. .false. .false. .true. .false.
(B **2 - 4*A*C) .GT. 0.
Le bloc IF
[ nom_bloc : ] IF( exp_1 ) THEN
bloc_1
[ ELSE IF( exp_2 ) THEN [ nom_bloc ]
bloc_2
ELSE IF( exp_3 ) THEN [ nom_bloc ]
bloc_3
...
ELSE [ nom_bloc ]
bloc_n ]
END IF [ nom_bloc ]
nom_bloc une étiquette facultative : si elle est présente elle doit figurer au niveau de
l’instruction END IF et peut apparaître à la suite des éventuelles instructions ELSE,
ELSE IF ;
expi une expression de type LOGICAL ;
bloci une suite d’instructions Fortran.
En l’absence de clause ELSE lorsque bloc1 est réduit à une seule instruction, la structure
IF se simplifie en :
IF (exp) instruction
Exemple
PROGRAM structure_if
REAL A,B, SUM
...
IF (A.LT.B) THEN
SUM = SUM + A
IF ( SUM > 0.) PRINT *, SUM
END IF
...
END PROGRAM structure_if
Exemple
PROGRAM structure_if
REAL A,HRS
...
IF ( HRS .LE .40.0) THEN
A = HRS *150.0
ELSE IF ( HRS .LE .50.) THEN
A = (HRS -40.0)*150.0*1.5
ELSE
A = (HRS -50.0)*150.0*2.0
END IF
END PROGRAM structure_if
L’instruction SELECT CASE permet des branchements multiples qui dépendent de la
valeur d’une expression scalaire de type entier, logique ou chaîne de caractères.
[ nom_bloc : ] SELECT CASE ( expression )
CASE ( liste ) [ nom_bloc ]
bloc_1
...
[ CASE DEFAULT [ nom_bloc ]
bloc_n ]
END SELECT [ nom_bloc ]
nom_bloc est une étiquette,
expression est une expression de type INTEGER, LOGICAL ou CHARACTER,
liste est une liste de constantes du même type que expression,
bloci est une suite d’instructions Fortran.
Exemple
PROGRAM structure_case
integer :: mois , nb_jours
logical :: annee_bissext
...
SELECT CASE ( mois )
CASE (4, 6, 9, 11)
nb_jours = 30
CASE (1, 3, 5, 7:8 , 10, 12)
nb_jours = 31
CASE (2)
! ----------------------------------
fevrier : select case ( annee_bissext )
case (. true .)
nb_jours = 29
case (. false .)
nb_jours = 28
end select fevrier
! ----------------------------------
CASE DEFAULT
print *, " Numéro de mois invalide "
END SELECT
END PROGRAM structure_case
L’instruction GOTO permet d’effectuer un branchement à un endroit particulier du code :
GOTO étiquette
Cette instruction est à éviter car elle peut générer des programmes illisibles et difficiles à
corriger.
Exemple
PROGRAM iteration_goto
REAL diviseur , valeur , facteur
...
valeur = 0. ; diviseur = 360.
69 IF ( diviseur .NE. 0.) THEN
valeur = valeur + facteur / diviseur
diviseur = diviseur - 10.
GOTO 69
END IF
...
END PROGRAM iteration_goto
Cet exemple peut être remplacé par une boucle itérative de type DO WHILE.
Il existe plusieurs types de boucles itératives qui sont toutes de la forme :
[ nom_bloc : ] DO [ contrôle_de_boucle ]
bloc
END DO [ nom_bloc ]
nom_bloc est une étiquette,
contrôle_de_boucle définit les conditions d’exécution et d’arrêt de la boucle,
bloc est une suite d’instructions Fortran.
1re forme : DO indéxé
contrôle_de_boucle est de la forme :
variable = expr1, expr2 [,expr3]
avec :
variable est une variable de type INTEGER,
expr1, expr2 et expr3 sont des expressions arithmétiques de type INTEGER.
Le nombre d’itérations est évalué avant le démarrage de la boucle.
Exemple
PROGRAM iteration_do
INTEGER i, somme , n
...
! affectation de n
somme =0
DO i=1,n ,2
somme = somme +i
END DO
...
END PROGRAM iteration_do
2re forme : DO WHILE
contrôle_de_boucle est de la forme :
WHILE (expression)
avec expression de type scalaire logique.
Le corps de la boucle est exécuté tant que l’expression est vraie.
Remarque : pour pouvoir sortir de la boucle, il faut que expression puisse prendre la
valeur .FALSE. dans le bloc.
Sommation de la série
P
n 1 1/n2 jusqu’à ce que le terme général soit inférieur à fois la
somme partielle courante :
Exemple
PROGRAM iteration_while
INTEGER :: n
DOUBLE PRECISION :: terme , somme
DOUBLE PRECISION , PARAMETER :: epsilon = 1.d -3
LOGICAL :: fini
! Initialisation
n=0
somme =0. d0
fini =. FALSE .
DO WHILE (. not . fini )
n=n+1
terme = 1d0/n**2
somme = somme + terme
fini =( terme .LT. epsilon * somme )
END DO
print *," Nombre d’ itérations : ", n
print *," Somme = ", somme
END PROGRAM iteration_while
3re forme : DO
Ce sont des boucles DO sans contrôle de boucle. Pour en sortir, on utilise une
instruction conditionnelle avec une instruction EXIT.
bloc est de la forme :
bloc_1
IF ( expression ) EXIT
bloc_2
avec :
expression une expression de type LOGICAL,
bloci des séquences de code Fortran.
Notons que la condition IF peut être remplacée par une instruction de type SELECT CASE.
Exemple
PROGRAM iteration_exit
REAL :: valeur
REAL :: x, xlast
REAL , PARAMETER :: tolerance = 1.0e -6
valeur = 50.
x = 1.0 ! valeur initiale ( diff . 0)
DO
xlast = x
x = 0.5 * ( xlast + valeur / xlast )
IF ( ABS (x- xlast )/x < tolerance ) EXIT
END DO
END PROGRAM iteration_exit
Instruction CYCLE
bloci peut aussi contenir une instruction CYCLE :
IF (expression) CYCLE
CYCLE permet d’abandonner le traitement de l’itération courante et de passer à la
suivante.
Là aussi, l’instruction IF peut être remplacée par une instruction de type SELECT CASE.
Exemple
PROGRAM iteration_cycle
INTEGER :: annee
DO
READ (* ,*) annee
IF ( annee .LE. 0) EXIT
! On élimine les années bissextiles .
IF( (( annee /4*4 .EQ. annee ) . AND . &
( annee /100*100 .NE. annee )) .OR. &
( annee /400*400 .EQ. annee ) ) CYCLE
PRINT *," Traitement des années non - bissextiles "
...
END DO
END PROGRAM iteration_cycle
