LANGAGE FORTRAN

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