Cours de Fortran

Cours de Fortran 90/ 95
CLAIRE MICHAUT
Claire.Michaut@obspm.fr
LUTH Observatoire de Paris
5, place Jules Janssen - 92195 Meudon Cedex
Master Recherche (M2)

Spcialit Astronomie & Astrophysique
Anne 2005 2006
cole doctorale dAstronomie et dAstrophysique dle-de-France - Cours de Fortran 90/ 95 - Claire Michaut
Table des Matires

I
Historique ........................................................................................................................6
II
Structure dun programme et syntaxe..............................................................................8

II.A
Units de Programme et procdures ......................................................................................... 8
II.A.1
Le programme principal............................................................................................................................9
II.A.2
Les procdures externes..........................................................................................................................10
II.A.3
Les modules.............................................................................................................................................13
II.B
Format et Syntaxe ...................................................................................................................... 15
II.B.1
Le format .................................................................................................................................................15
II.B.2
Les identificateurs et la syntaxe..............................................................................................................15
II.B.3
Commentaires..........................................................................................................................................16
II.B.4
Chanes de caractres ..............................................................................................................................16
II.C
Les types et les dclarations ...................................................................................................... 16
II.C.1
Dclaration de variables scalaires...........................................................................................................17
II.C.2
Dclaration de constantes .......................................................................................................................17
II.C.3
Sous-type: la prcision des nombres .....................................................................................................18
II.C.4
Les fonctions intrinsques lies la prcision .......................................................................................19
II.D
Autres types ................................................................................................................................ 20
II.D.1
Les tableaux.............................................................................................................................................20
II.D.2
Les types drivs .....................................................................................................................................21
II.D.3
Vers un langage orient objet .................................................................................................................22
II.E
III
Les fonctions intrinsques......................................................................................................... 23
Structures de contrle ................................................................................................25
III.A
Le choix avec IF.......................................................................................................................... 25
III.B
Le choix avec SELECT CASE.................................................................................................. 26
III.C
Le choix avec WHERE .............................................................................................................. 28
III.D
La boucle DO .............................................................................................................................. 29
III.D.1
Clause de contrle itrative................................................................................................................29
III.D.2
Clause de contrle WHILE................................................................................................................30
III.D.3
Boucle infinie et altration.................................................................................................................31
III.E
IV
Le schma FORALL.................................................................................................................. 31
Les tableaux...............................................................................................................32
IV.A
Gestion mmoire des tableaux .................................................................................................. 32
IV.A.1
Lallocation statique .......................................................................................................................... 32
IV.A.2
Lallocation dynamique ..................................................................................................................... 32
IV.B
La manipulation des tableaux................................................................................................... 35
IV.C
Les fonctions intrinsques sur les tableaux ............................................................................. 38
IV.C.1
Les fonctions dinterrogation ............................................................................................................ 38
IV.C.2
Les fonctions de rduction................................................................................................................. 39
IV.C.3
Les fonctions de construction et de transformation.......................................................................... 42
IV.C.4
Les fonctions propres aux matrices et vecteurs ................................................................................ 44
Les pointeurs..................................................................................................................46
V.A
Introduction................................................................................................................................. 46
V.A.1
Dfinition: ......................................................................................................................................... 46
V.A.2
Dclaration dun pointeur et dune cible........................................................................................... 46
V.B
tat dun pointeur ...................................................................................................................... 46
V.C
Lallocation dynamique ............................................................................................................. 48
V.C.1
VI
Contrle de visibilit ..................................................................................................52
VI.A
VII
En argument de procdure...................................................................................................................... 49
Les ressources prives et publiques......................................................................................... 52
VI.A.2
les types drivs semi-privs ............................................................................................................. 53
VI.A.3
Restriction de l'instruction USE ........................................................................................................ 54
Contrle de cohrence ...............................................................................................56
VII.A
Les arguments de procdure ................................................................................................ 56
VII.A.1
Vocation des arguments..................................................................................................................... 56
VII.A.2
Prsence optionnelle des arguments.................................................................................................. 58
VII.A.3
Passage d'arguments par mots cls.................................................................................................... 59
VII.B
Interface de procdure .......................................................................................................... 60
VII.B.1
Bloc interface dans lunit appelante ................................................................................................ 61
VII.B.2
Bloc interface dans un module .......................................................................................................... 62
VII.B.3
Rcapitulatif sur linterface explicite ................................................................................................ 65
VII.C
Interface gnrique ................................................................................................................ 65
VII.D
Surcharge et cration doprateurs ..................................................................................... 66
VII.D.1
Interface OPERATOR ....................................................................................................................... 67
VII.D.2
Interface ASSIGNMENT .................................................................................................................. 68
VIII
Les entres/ sorties ....................................................................................................70
VIII.A
Instructions gnrales ........................................................................................................... 70
VIII.A.1
VIII.B
Description des paramtres de lecture/ criture ...............................................................................71
Ouverture de fichiers ............................................................................................................ 74
VIII.B.1
VIII.C
Description des paramtres douverture............................................................................................74
Linstruction inquire............................................................................................................. 76
VIII.C.2
VIII.D
Par liste de sortie ................................................................................................................................77
Linstruction namelist........................................................................................................... 77
VIII.D.1
Dclaration .........................................................................................................................................78
VIII.D.2
Usage ..................................................................................................................................................78
IX
ANNEXE ...................................................................................................................80
IX.A
Quelques fonctions intrinsques............................................................................................... 80
IX.A.1
Manipulation de bits...........................................................................................................................80
IX.A.2
Prcision et codage numrique ..........................................................................................................81
IX.A.3
Fonctions numriques lmentaires ..................................................................................................82
IX.A.4
Fonctions lmentaires de type caractre..........................................................................................83
IX.B
Fonctions de gnration de nombres alatoires ..................................................................... 84
IX.C
Horloge en temps rel ................................................................................................................ 85
IX.D
Sites intressants ........................................................................................................................ 86
IX.E
Bibliographie .............................................................................................................................. 86
HISTORIQUE
Au dbut de l'informatique, le fait de programmer se rvlait fastidieux et peu fiable. Puis apparut
une codification directe des instructions machines, connue sous le nom de code assembleur. Dans les
annes 50, il devint vident quune nouvelle tape dans les techniques de programmation devait tre
franchie.
Cest pourquoi, lanne 1954 voit natre le projet du premier langage symbolique par John Backus
de la socit IBM; Mathematical Formula Translating System dit FORTRAN. Ce langage permet pour
la premire fois lutilisateur de se concentrer sur le problme rsoudre et non sur les instructions de
la machine.
1956- Premier manuel de rfrence qui dfinit le FortranI. Les noms de variables ont jusqu six
caractres et linstruction FORMAT est introduite.
1957- Le FortranII fait son apparition ainsi que les premiers compilateurs commerciaux. Les
sous-programmes et fonctions sont accepts et deviennent compilables indpendamment les uns des
autres.
1958- la fin de lanne, le FortranIII est disponible, mais reste interne la compagnie IBM.
Certaines des nouveauts implantes sont le type logique, les paramtres de procdures.
1962- Le FortranIV est n et restera le langage informatique des scientifiques pendant seize ans.
Il apporte les dclarations de type explicites et linstruction dinitialisation DATA. Entre temps, les
autres constructeurs dveloppent leur compilateur; il faut bientt tablir une norme.
1966- Cration de la norme ANSI (American National Standards Institutes), le FortranIV est
rebaptis Fortran66.
1978- La norme Fortran 77 (ou Fortran V) modernise le langage, car cest la fin des cartes
perfores. On lui doit le type caractre, de meilleures entres/ sorties, un dbut de programmation
structure et des fonctions prdfinies portant un nom gnrique.
Dans le milieu des annes 80, la reconversion Fortran 77 tait bien engage alors que Fortran 66
perdait considrablement du terrain.
Aprs 30 ans d'existence, Fortran n'est plus le seul langage de programmation disponible, mais il
est rest prdominant dans le domaine du calcul numrique l'usage des chercheurs, des techniciens et
des ingnieurs. Dans le but de maintenir le langage correctement jour, le Comit technique X3J3
accrdit par l'ANSI a labor une nouvelle norme.
1991- La norme internationale ISO/ANSI Fortran90 apparat dote dinnovations changeant
profondment le langage. Le Fortran devient modulaire, il permet un calcul vectoriel et un contrle de
la prcision numrique. De plus il devient plus fiable grce aux blocs interfaces et soriente vers une
programmation objet.
1995- Les caractristiques dprcies ou obsoltes forment le Fortran 95 et il admet une structure
vectorielle supplmentaire (FORALL) et quelques autres amliorations.
2002- Fin des travaux pour la norme Fortran 2000, publication prvue pour fin 2004 pour la
norme ISO.
Fortran 2005: Correction de Fortran 2000 et probablement dernire norme Fortran.
Plus tard, va-t-on vers un langage F, FOO, F++?
II
II.A
STRUCTURE DUN PROGRAMME ET SYNTAXE
UNITS DE PROGRAMME ET PROCDURES
De faon trs gnrale, la taille des programmes que lon est amen dvelopper aujourdhui
devient considrable. Les ordinateurs sont de plus en plus puissants, ils sont alors de plus en plus
sollicits dans la vie courante. Et lexigence de lutilisateur na plus de limite. Quant aux chercheurs et
leurs dsirs, rien ne saurait les dcourager, pas mme des dizaines de milliers de lignes de calculs. Or,
ds que lon envisage un travail un tant soit peu ambitieux, on a de plus en plus souvent besoin de
comptences multiples. Cest--dire que les programmes sont dvelopps par plusieurs personnes, qui
hormis le langage informatique commun ne parlent pas forcment le mme jargon technique.
Cest pourquoi, nous avons besoin dun langage structur et dun langage modulaire. La structure
permet une bonne lisibilit dun programme, donc une bonne comprhension et une matrise du codage.
Cest--dire que lon rsout effectivement le problme donn et pas un ersatz qui fonctionne dans 97%
des cas, voire moins! La modularit permet de rpondre aux besoins du Gnie Logiciel. Les modules
fonctionnent quasiment comme des botes noires, ce qui permet dincorporer dans un programme des
parties indpendantes les unes des autres et ne ncessitant pas forcment aux autres dveloppeurs de
prendre connaissance de leur contenu. Il suffit de connatre le nom dappel des procdures dont on a
besoin.
La notion dobjet est plus forte encore, et on les manipule alors compltement comme des botes
noires. Lobjet ralise lui-mme lencapsulation de ses donnes et empche tout accs depuis
lextrieur.
En rcapitulant, Fortran 90 facilite la manipulation des structures (objet de type driv), en offrant
les possibilits suivantes.
Il permet de dfinir des fonctions de manipulation de ces structures:
surcharge des oprateurs +, -, * ,
de nouveaux oprateurs en les associant aux fonctions correspondantes,
autres fonctions ou procdures agissant sur ces structures;
Il permet d'encapsuler le type et les fonctions oprant sur les objets de ce type dans un module
spar. Ce qui permettra d'y accder facilement (USE<module>) en diminuant les sources
d'erreurs, dans toutes les units de programme en ayant besoin;
Il permet de rendre prive les composantes de la structure. Si la dfinition du type se fait dans
un module spar (encapsulation), seules les fonctions ou procdures internes au module ont
accs aux composantes prives (PRIVATE) et peuvent les modifier (scurit).
Sans tre un vrai langage orient objet, Fortran 90 fournit ainsi des extensions objet bien utiles
pour la structuration du programme et sa fiabilit.
Un programme est compos dunits de programme, qui sont:
un programme principal, contenant une procdure interne;

des procdures externes;
des modules.
Les procdures externes peuvent tre crites dans des modules, elles deviennent internes au
module. Un module peut contenir des procdures, des dclarations, des affectations de variables, des
types drivs et des blocs interfaces.
Les mots cls sont:
PROGRAM, END PROGRAM;

MODULE, END MODULE;
CONTAINS;
SUBROUTINE, END SUBROUTINE;
FUNCTION, END FUNCTION.
II.A.1
Le programme principal
Le programme principal est une unit de compilation, mais il a la particularit dtre la seule qui
soit excutable. Donc il est la seule qui soit totalement obligatoire. Le programme principal prend
toujours la forme suivante:
PROGRAM nom_du_programme
[instructions de spcification]
[instructions excutables]
CONTAINS
[procdures internes]
END PROGRAM nom_du_programme
L'instruction PROGRAM est facultative, mais conseille. L'instruction END qui gnre l'arrt du
programme est obligatoire. Les instructions de spcification sont des instructions de dclaration, des
dfinitions de type, des blocs INTERFACE. L'instruction CONTAINS indique la prsence d'une ou
plusieurs procdures.
Exemple II.1
PROGRAM ETOILE
USE DONNEES
IMPLICIT NONE
REAL :: r1, u1, T1
r1 = 1.e-3 ; u1 = 45000. ; T1 = 55635.
r1 = G * u1 * T1
PRINT*,"r1 vaut ", r1
END PROGRAM ETOILE
II.A.2 Les procdures externes

Une procdure externe est appele depuis une autre unit de programme. Elle a une forme
similaire celle du programme principal, tant du point de vue de sa syntaxe que de son excution. elle
prend place On en distingue deux sortes: les sous-programmes et les fonctions. De plus, on distingue
des procdures globales, contenues dans un module et utilisables par lensemble des autres units de
programme, des procdures internes, contenues dans une procdure globale et utilisables uniquement
par leur hte.
a) Les sous-programmes
Les sous-programmes, dfinis par le mot-cl SUBROUTINE, dfinissent une action au moyen de
toutes les instructions du langage, dont lappel prend lui-mme la forme et lapparence dune instruction
du langage. La syntaxe gnrale dun sous-programme est la suivante:
SUBROUTINE nom_du_sous-programme [(arguments)]

[CONTAINS
[procdures internes]]
END SUBROUTINE [nom_du_sous-programme]
Les sous-programmes sont appeles, depuis une autre procdure (ou programme principal), avec
linstruction CALLnom_du_sous-programme[(arguments)].
b) Les fonctions
Les fonctions, dfinis par le mot-cl FUNCTION, calculent une valeur au moyen de toutes les
instructions du langage, dont lappel prend place au sein dune expression. La syntaxe gnrale dune
fonction est la suivante:
10
[TYPE] FUNCTION nom_de_la_fontion (arguments)

[CONTAINS
END FUNCTION [nom_de_la_fonction]
Les fonctions sont appeles directement laide de leur nom propre et de leurs arguments, depuis
une autre procdure (ou programme principal). On peut dclarer leur type avant linstruction
FUNCTION.
Exemple II.2
SUBROUTINE LOCATE (rr, TT, m, n, hmn)

IMPLICIT NONE
REAL, INTENT(IN) :: rr, TT
INTEGER, INTENT(OUT) :: m, n
REAL, OPTIONAL, DIMENSION(4), INTENT(OUT) :: hmn
REAL:: hm, hn, hm1, hn1, Vol
m = 1; n = 1
DO
m = m + 1
n = n + 1
END DO
IF (PRESENT(hmn)) THEN
! Calcul des poids pour linterpolation des donnees.
hm = TT - TeV(m) ; hm1 = TeV(m+1) - TT
hn = rr - rho(n) ; hn1 = rho(n+1) - rr
Vol = (hm + hm1) * (hn + hn1)
hmn(1) = hm * hn / Vol
hmn(2) = hm1 * hn / Vol
hmn(3) = hm * hn1 / Vol
hmn(4) = hm1 * hn1 / Vol
END IF
END SUBROUTINE LOCATE
11
Exemple II.3
REAL FUNCTION ZMOY (rr, TT)

IMPLICIT NONE
REAL, INTENT(IN) :: rr, TT
CALL LOCATE (rr, TT, m, n, hmn)
zmoy = zbar(m,n)
* hmn(4) + zbar(m+1,n)
* hmn(3) &
+ zbar(m,n+1) * hmn(2) + zbar(m+1,n+1) * hmn(1)
zmoy = 1. + zmoy
END FUNCTION ZMOY
c)
Les procdures rcursives
Dans certains cas particuliers, on a besoin quune procdure puisse sappeler elle-mme.
Dordinaire, cette structure de programmation est impossible. Cest pourquoi, il faut tout dabord avertir
le compilateur de ce mode de fonctionnement: on utilise lattribut RECURSIVE devant le nom de la
procdure, quelle soit un sous-programme ou bien une fonction. Attention toutefois au temps de calcul,
qui peut devenir prohibitif, lors de plusieurs appels rcursifs successifs !
Syntaxe gnrale:
recursive subroutine nom_proc (list_arg)

recursive function nom_proc (list_arg) result (nom_res)
Remarque: dans le cas dune fonction, on est oblig dutiliser un nom de rsultat diffrent du nom
de la fonction, dfini laide du mot cl RESULT.
Les fonctions rcursives peuvent tre, par exemple, trs utiles pour traiter des suites
mathmatiques, qui par dfinition, sont construites en rfrence au rang infrieur. Ainsi pour calculer la
suite arithmtique:
u1 = 1; u2 = 3 ; un = 3un1 un2
12
n3
Exemple II.4
RECURSIVE FUNCTION SUITE (n) RESULT (u)

INTEGER, INTENT (IN) :: n
INTEGER :: u
SELECT CASE (n)
CASE (1)
u = 1
CASE (2)
u = 3
CASE DEFAULT
u = 3 * suite (n-1) - suite (n-2)
END SELECT
END FUNCTION SUITE
Remarque: Le mot-cl RESULT peut tre utilis dans toutes les fonctions pour dfinir le nom du
rsultat, quelles soient rcursives ou non. Le type du rsultat est toujours celui de la fonction.
II.A.3
Les modules
Un module est une unit de compilation qui a pour fonction de mettre disposition, aux autres
units de compilation, des ressources logicielles comme des constantes, des variables, des types et des
procdures. Cest une abstraction des donnes et des procdures quil encapsule, ralisant ainsi une
bote noire pour lutilisateur et favorisant la maintenance des applications. Le module nest pas
excutable, il ny a que le programme principal qui le soit. La forme gnrale dun module est la
suivante:
MODULE nom_du_module
[CONTAINS
[procdures globales]]
END MODULE [nom_du_module]
13
Exemple II.5
MODULE DONNEES
IMPLICIT NONE
REAL, PARAMETER :: Rgaz = 8.314e7
CONTAINS
SUBROUTINE INIT (r1, u1, T1)
IMPLICIT NONE
REAL, INTENT(IN) :: r1, u1, T1
REAL :: gam, Mach
gam = 5./3.
! Mach = u1/Csound ; nombre de Mach
Mach = u1 * sqrt(131/(gam*Rgaz*T1))
WRITE (6,*) "Le nombre de Mach est de ", Mach
END SUBROUTINE INIT
END MODULE DONNEES
a) Accs aux ressources dun module
Laccs aux ressources dun module se fait grce linstruction use nom_module. Cette ligne
dinstruction se place toujours en tte de lunit utilisatrice, avant le bloc dclaratif et permet
limportation de lintgralit du module dans cette unit de compilation.
PROGRAM (ou SUBROUTINE, FUNCTION)

USE Nom_de_Module1
USE Nom_de_Module2
IMPLICIT NONE
END PROGRAM (ou SUBROUTINE, FUNCTION)

On peut toutefois restreindre laccs certaines ressources du module uniquement, en important
partiellement le module. Pour ce faire, on place linstruction only: suivie dune liste exhaustive des
ressources souhaites, derrire la commande dimportation du module.
USE Nom_de_Module, ONLY: var1, var2, sous-programme1

b) Renommer les importations
Pour des raisons de lisibilit dun programme, ou bien de compatibilit de plusieurs procdures, il
est parfois souhaitable de renommer les entits importes. On utilise la double flche qui est aussi le
symbole daffectation des pointeurs.
USE Nom1_de_Module => Nom2, ONLY: var1 => xy, var2

14
II.B
FORMAT ET SYNTAXE
II.B.1
Le format
En Fortran 90, on utilisera de prfrence le format libre, qui est une nouveaut de cette norme. Les
lignes ont une longueur maximale de 132 caractres. On peut coder plusieurs instructions sur une mme
ligne en les sparant par un point-virgule ;. Une instruction peut scrire sur plusieurs lignes en
utilisant le caractre de continuation esperluette &. Une chane de caractres crite sur plusieurs
lignes doit tre prcde du & en plus de celui de continuation de la ligne prcdente.
Exemple II.6
rr = rho_init ; uu = Cshock ; TT = Temp

PRINT*, "Dans ce calcul le flux final est ",
& Frad, "et l'opacite est ",
& KRoss
Exemple II.7
PRINT*, "Dans ce calcul le flux final et&

&lopacite sont ", Frad,
& KRoss
II.B.2
Les identificateurs et la syntaxe
Un identificateur est compos dune suite de caractres, limite 31, choisis parmi les lettres (non
accentues), de chiffres (sauf en premire position) et du caractre espace soulign:_.
Lidentificateur sert nommer les objets que le programmateur veut manipuler. Le compilateur ne
distingue pas les majuscules des minuscules, mais on peut toutefois sen servir par soucis de lisibilit.
Exemple II.8: identificateurs autoriss
clight
Nom_de_famille
TypeOfGas
M2
Exemple II.9: identificateurs non autoriss
Nom de famille
TypeOfGas
2M
En Fortran 90, il nexiste pas de mots rservs, on peut donc utiliser des mots cls du langage
comme identificateur. Dans lidal, mieux vaut viter de le faire, pour limiter les risques de confusion.
Un espace est ncessaire entre identificateurs, mots cls et nombres.
15
II.B.3
Commentaires
Un commentaire commence par le caractre point dexclamation! et se termine par la fin de

ligne. Donc, il est possible d'insrer des commentaires aprs des instructions, sur une mme ligne, mais
pas avant.
Exemple II.10
! gam: rapport des capacites de pression & volume

! constants: Cp / Cv.
gam = 5. / 3.
! Mach = u1/Csound ; nombre de Mach
Mach = u1 * sqrt(AtW/(gam*Rgaz*T1)) !adimensionne
PRINT*, "Le nombre de Mach est de ", Mach
gM2 = gam*Mach*Mach
! adimensionne
II.B.4
Chanes de caractres
Les chanes de caractres sont encadres par des cotes simples ou doubles ". Elles
neutralisent leffet de tous les autres signes ou mots cls.
Exemple II.11
! Le point dexclamation est utilise comme tel

! dans une chaine de caracteres. dans ce cas
PRINT*, "Le nombre de Mach est grand! "
"Llphant est + grand que la souris."
3 * plus souvent
II.C
LES TYPES ET LES DCLARATIONS
Comme toute information stocke en mmoire est code en binaire, il faut une cl pour connatre
la reprsentation initiale de tel ou tel octet. Ainsi une chane de caractres, un nombre ou une valeur
logique peuvent avoir dans labsolu la mme reprsentation binaire, suivant le codage utilis. Cest
pourquoi, nous devons annoncer quel type dobjets nous manipulons, pour diffrencier leur codage
binaire. Le Fortran 90 prvoit cinq types de bases et des combinaisons.
logical, character, integer, real, double precision

complex, type
Il est possible de dfinir de nouveaux types de donnes partir d'un groupe de donnes appartenant
des types intrinsques, laide de la dclaration type. Nous verrons ce point ultrieurement.
De plus on distingue les constantes, les variables scalaires, les vecteurs et tableaux au moyen
dattributs. Ces attributs servent spcifier ce que le programmateur souhaite faire de ces donnes
dclares et permettent un contrle de la bonne utilisation de ces donnes.
16
La forme gnrale de la dclaration d'une variable est la suivante:
type [[,liste_attributs] :: ] liste_objets

La liste des attributs est la suivante:
parameter, dimension, allocatable, pointer, target,

save, intent, optional, public, private, external,
intrinsic
Nous expliquerons leur signification au fur et mesure de leur introduction dans les diffrents
chapitre du cours.
II.C.1
Dclaration de variables scalaires

CHARACTER (LEN=12) :: elmt
INTEGER, PRIVATE :: mmax, nmax
INTEGER :: AtN ; REAL :: AtW
REAL :: gM2, CvM2, ww, gam = 5./3.
DOUBLE PRECISION:: x=5.d-4
COMPLEX:: z1=(3,5), z2
On voit que lon peut initialiser les variables lors de leur dclaration. Toute variable initialise
devient permanente, elle reoit donc implicitement lattribut save.
II.C.2
Dclaration de constantes
Ces objets reoivent lattribut parameter, et doivent obligatoirement tre initialiss lors de leur
dclaration. Il devient alors interdit de changer leur valeur dans une instruction.
CHARACTER (LEN=12) :: elmt=nomdefamille

REAL, PARAMETER :: clight = 2.99791e10, Rgaz = 8.314e7
COMPLEX, PARAMETER:: z1=(3,5), z2=(6,9)
DOUBLE PRECISION, PARAMETER:: x=5.d-4
Toutefois, certains programmateurs auront recours au typage par dfaut. On commence par une
dclaration du type:
IMPLICIT REAL (a-h, o-z)

Ainsi tous les identificateurs commenant par une lettre de cet ensemble alphabtique (de a h ou
de o z) seront automatiquement considrs comme des rels. Sauf, si une dclaration contraire est
faite. Cette mthode de dclaration est pratique au commencement, car moins fastidieuse. Mais elle est
source dinnombrables erreurs! Par exemple, elle ne dtecte pas les fautes de frappe, pourtant si
nombreuses. Le Fortran 90 est justement un langage dvelopp dans le but de prvenir au maximum des
erreurs de programmation, donc il est absurde de se passer de cet atout.
Cest pourquoi, il est vivement conseill dinsrer linstruction:
17
IMPLICIT NONE
avant tout bloc de dclaration. Ce qui oblige le programmateur dclarer explicitement chaque variable.
La dclaration laide du mot cl TYPE sert crer des types drivs dfinis par le
programmateur. Nous verrons ce point ultrieurement, dans le chapitre II.D.
II.C.3
Sous-type: la prcision des nombres

a) Avec le mot cl KIND
Les types de base en Fortran 90 sont en fait des noms gnriques renfermant chacun un certain
nombre de sous-types que l'on peut slectionner l'aide du mot cl KIND, lors de la dclaration des
objets. Pour chaque type prdfini correspond un sous-type par dfaut, cest la simple prcision en
gnral.
Les diffrentes valeurs du paramtre KIND sont dpendantes du systme utilis et elles
correspondent au nombre d'octets dsirs pour coder l'objet dclar. Pour les chanes de caractres,
KIND sert indiquer combien doctets sont ncessaires pour coder chaque caractre! Cest utile dans
des alphabets complexes.
Dans une dclaration, on indique soit directement le nombre doctets, soit on donne un exemple du
sous-type dsir.
Exemple II.12
REAL (KIND=8) :: x
rel cod sur 8 octets:
double prcision pour la plupart des calculateurs,
et simple prcision sur Cray C90, par exemple.
INTEGER (KIND=2) :: k entier cod sur 2 octets.
En donnant le sous-type directement en exemple, au lieu du nombre doctets.
Exemple II.13
REAL, (KIND = KIND(1.d0)):: x

rel double prcision quelque soit la machine utilise.
b) Avec des suffixes ou prfixes
Une autre manire de prciser le sous-type dsir lors de l'criture des variables est de leur ajouter
un suffixe pour les constantes numriques, ou bien un prfixe pour les chane de caractres, qui contient
la valeur du sous-type choisi. On insre le caractre _ entre la variable et le suffixe ou prfixe.
18
Exemple II.14
123456_2
34.567005678001_8
2_fleur
entier cod sur 2 octets

rel cod sur 8 octets
chane de caractres, chacun cod
sur 2 octets
ou bien
Exemple II.15
INTEGER, PARAMETER::
123456_deux
34.567005678001_huit
deux_fleur
II.C.4
deux = 2, huit = 8
entier cod sur 2 octets
rel cod sur 8 octets
chane de caractres, chacun cod
sur 2 octets
Les fonctions intrinsques lies la prcision

a) selected_int_kind (m)
Cette fonction retourne un paramtre de sous-type qui permet de reprsenter les entiers n, en
fonction de ltendue choisie laide de lentier m, tels que:
-10m < n < 10m

Elle retourne -1 si aucun paramtre de sous-type ne rpond la demande.
Exemple II.16
SELECTED_INT_KIND(30)
retourne -1
retourne 8
retourne 4
b) selected_real_kind (p, r)
Cette fonction reoit au moins un des deux arguments p et m qui sont respectivement la prcision
et l'tendue choisies. Elle renvoie un paramtre de sous-type qui permet de reprsenter les rels
rpondant cette prcision, tels que:
10-r < |x| < 10r

La fonction renvoie:
-1 si la prcision demande n'est pas disponible;
-2 si l'tendue n'est pas disponible;
-3 si la prcision et l'tendue ne sont pas disponibles.
19
Exemple II.17
SELECTED_REAL_KIND(2,30)
c)
retourne
retourne
retourne
retourne
retourne
4
16
8
4
-2
range et precision
En complment, ltendue dun nombre est connue laide de la fonction RANGE.

La prcision dun rel (nombre significatif de chiffres derrire la virgule) est connue avec la
fonction PRECISION.
Exemple II.18
RANGE(1234567890)
RANGE(123456.7890)
PRECISION(1.234567890)
II.D
retourne 9
retourne 37
retourne 6
AUTRES TYPES
Dans un souci de fiabilit dans lexcution et lutilisation dun programme, ou une partie, on est
amen dfinir un ensemble de variables. Le fait de les ranger ainsi sous un mme nom de type et dans
un seul type prvient derreurs de manipulation de ces variables et facilite leur dclaration. Les tableaux
sont dj des objets qui regroupent en ensemble de variables, mais cest un cas particulier qui impose
que toutes ces variables soient strictement du mme type.
Dans le cas dobjets plus complexes, regroupant des donnes (champs ou composantes) de
diffrents types, nous allons dfinir un type driv (ou structure) qui tend les types prdfinis, et qui
permet de manipuler ces objets globalement. Chaque composante est identifie par son nom, elle peut
tre soit de type intrinsque soit galement de type driv.
II.D.1
Les tableaux
Un tableau est un ensemble de variables qui sont toutes du mme type, il peut tre prdfini ou de
type driv. Chacune des variables est repre par un indice numrique. La forme dclarative gnrale
est la suivante:
TYPE, DIMENSION () [,liste_attributs] :: nom_tableau

Un tableau peut avoir une taille statique, dans ce cas, sa dimension est explicitement crite lors de
la dclaration. Ou bien il a une taille dynamique, cest--dire quelle sera dfinie en fonction de
lexcution du programme, dans ce cas, la dimension est suggre par le caractre deux-points :.
20
Dans le paragraphe consacr aux tableaux et leur manipulation, nous reviendrons sur les formes
dclaratives des tableaux de taille dynamique.
CHARACTER (LEN=8), DIMENSION (15):: mois

INTEGER, DIMENSION (12,31):: jour
LOGICAL, DIMENSION (2) :: reponse = (/.true.,.false./)
REAL, DIMENSION (:,:,:) :: position
INTEGER, DIMENSION(4), PRIVATE :: hmn
REAL, DIMENSION (:), ALLOCATABLE :: TeV, rho
II.D.2
Les types drivs

a) Construction dun type driv (ou structure)
Pour construire une nouvelle structure, on utilise la syntaxe suivante:
type nom_type
bloc_declaratif_des_champs
end type nom_type
Restriction du bloc dclaratif:
Lattribut PARAMETER nest pas autoris au niveau dun champ.
Lattribut ALLOCATABLE est interdit au niveau dun champ.
Lattribut POINTER est autoris au niveau dun champ, mais pas TARGET.
Linitialisation dun champ nest possible quen Fortran 95.
Attention:
Un objet de type driv est toujours considr comme un scalaire, mme si un champ possde
lattribut DIMENSION.
Les tableaux dobjets de type drivs sont autoriss et ils peuvent bnficier de lattribut
ALLOCATABLE.
Dfinition multiple de la structure: si le type driv n'est pas dfini de manire unique, par
exemple lorsque la structure est passe en argument de procdure, lattribut SEQUENCE est
obligatoire. Il assure un stockage en mmoire dans le mme ordre des composantes en
mmoire.
b) Manipulation dun objet de type driv

Pour utiliser des variables du type driv prcdemment dfini, on dclare simplement:
type (nom_type) [,liste_attributs] :: nom_var

Pour accder aux champs de lobjet que nous venons de dfinir, nous utiliserons le caractre pour
cent %. Pour le reste des oprations, la structure ainsi dfinie se manipule comme nimporte quelle
variable.
21
c)
Exemples
Par exemple, un vtrinaire voudrait crer un type driv animal, dans lequel seraient recenss
la race, lge, la couleur et ltat de vaccination de ses patients.
Exemple II.19
TYPE animal
CHARACTER (LEN=20) :: race
REAL :: age
CHARACTER (LEN=15) :: couleur
LOGICAL, DIMENSION(8) :: vacc
END TYPE animal
Il peut ensuite manipuler globalement lobjet animal, ou bien accder chacun de ses champs,
grce loprateur %.
Pour dclarer de nouveaux animaux, il utilise la forme suivante:
Exemple II.20
TYPE (animal):: ponpon, rox, roucky

Pour rentrer les informations concernant ces nouveaux patients:
Exemple II.21
ponpon%race = chat_de_gouttiere
ponpon%age = 12
ponpon%couleur = noir
ponpon%vacc = (/.true.,.false., .true., .true.,&
.false. ,.false., .true., .true./)
II.D.3
Vers un langage orient objet
Fortran 90 nest pas un langage orient objet, proprement parl, mais il sen rapproche, car il
possde des extensions objet qui accroissent la fiabilit des programmes et procurent un confort de
programmation. En fait, il lui manque quelques notions, comme la hirarchie de types drivs avec
hritage. La norme Fortran 2000 les prvoit.
Fortran 90 facilite cependant la manipulation des structures (objets de type driv), car il permet:
la dfinition dautres fonctions de manipulation des structures, comme:
la surcharge des oprateurs +, -, * ,
de nouveaux oprateurs en les associant aux fonctions correspondantes,
des autres fonctions ou procdures agissant sur ces structures.
d'encapsuler le type et les fonctions oprant sur les objets de ce type, dans un module spar.
Ce qui permettra d'y accder facilement, avec linstruction USE nom_module
de rendre prives les composantes interne dune structure, avec linstruction PRIVATE.
22
Ces diffrents point seront abords ultrieurement.
II.E
LES FONCTIONS INTRINSQUES
Fortran 90 possde une librairie trs complte de fonctions sur les scalaires. On trouvera bien sr
toutes les fonctions mathmatiques habituelles sur les entiers, les rels, et les complexes. Nous ne
prsenterons pas ces fonctions dans ce cours.
De plus Fortran 90 possde des fonctions:
de manipulation de bits;
de manipulation de chanes de caractres;
de conversion de type;
dinterrogation sur les variables;
des fonctions intrinsques lies lutilisation de tableaux (voir le Chapitre IV.C).
Ces fonctions sont nommes et expliques tout au long du cours, suivant le sujet dvelopp.
23
24
III
STRUCTURES DE CONTRLE
lorigine, les instructions dun programme sont squentielles: elles sont excutes au fur et
mesure de leur ordre dapparition. Mais rapidement, un programme plus labor a besoin dune
souplesse de contrle: dans tel cas faire ceci, par contre dans tels autre cas faire cela, le refaire n fois,
etc. On a donc besoin dinstructions pour faire des choix et des boucles.
Le programme sera alors crit comme une suite de blocs. Un bloc peut-tre contenu dans un autre,
mais seulement au niveau infrieur. Il ny a pas dimbrication possible, sur le mme niveau de priorit.
Ces suites de blocs forment le langage structur et augmentent la lisibilit du programme.
Un bloc est compos dune instruction initiale contenant le mot cl de la structure, de mots cls
intermdiaires et est ferm par un END mot cl de la structure.
Les mots cls dfinissant les blocs sont:
IF THEN, ELSE IF THEN, END IF

DO, CYCLE, EXIT, END DO
DO WHILE, END DO
SELECT CASE, CASE, CASE DEFAULT, END SELECT
WHERE, ELSEWHERE, END WHERE
FORALL, END FORALL
III.A
LE CHOIX AVEC IF
La construction typique dun bloc est la suivante:
IF (expression_logique) THEN
bloc1
ELSE
bloc2
END IF
Avec ses variantes:
IF (expression_logique1) THEN
bloc1
ELSE IF (expression_logique2) THEN
bloc2
END IF
25
Ou plus directement:
IF (expression_logique) THEN
bloc1
END IF
Et encore plus simple, en une seule phrase:
IF (expression_logique)
bloc1
Le bloc IF peut tre tiquet, comme les autres structures prsentes dans la suite. Dans ce cas,
ltiquette doit tre rpte au niveau du END, sa suite. Ltiquette est un identifiant de la structure,
cest--dire un nom; lorsquelle est optionnelle, elle augmente la lisibilit du programme ou bien elle
est rendue obligatoire par la logique du programme. La syntaxe est la suivante:
nom : IF (expression_logique) THEN

bloc1
END IF nom
Exemple III.1
stab = f(1,2) * f(2,2)

IF (stab >= 1.01) THEN
ecart = stab - 1.
h = 0.5 * h
ELSE IF (stab <= 0.99) THEN
ecart = 1. - stab
h = 0.5 * h
ELSE
count = count + 1
z = z + h
f(3,1) = f(1,2)
END IF
III.B
LE CHOIX AVEC SELECT CASE
Cest une construction compltement nouvelle en Fortran, elle permet de faire un choix multiple,
sans expression logique, car le test porte sur une valeur unique de la variable.
La syntaxe gnrale est la suivante:
26
[nom:] SELECT CASE (var)

CASE (val1)
bloc1
CASE (val2)
bloc2
CASE DEFAULT
bloc default
END SELECT [nom]
O val1, val2.. sont des valeurs que peut prendre la variable selectionne var.
Le cas par dfaut englobe tous ceux qui nont pas t explicitement mentionns, il est optionnel.
Exemple III.2
SELECT CASE (K)

CASE (1) ! On integre en montant.
PRINT*,"Integration directe : "
h = Long*1.2 / REAL(nstep)
f(1,1) = 1. ; f(2,1) = 1.5 ; f(3,1) = 0.
z = 0.
nom_fichier1 = name
CASE (2) ! On integre en descendant.
PRINT*,"Integration inverse : "
h = -Long*1.2 / REAL(nstep)
f(1,1) = r2/r1 ; f(2,1) = u2/u1 ;
f(3,1) = T2/T1
z = Long
nom_fichier2 = name
END SELECT
27
Exemple III.3
element: SELECT CASE (AtN)

! AtN : n atomique - AtW : Poids atomique
CASE (1:9)
elmt = 'trop_leger' ; AtW = 0.
CASE (12)
elmt = 'magnesium' ; AtW = 24.305
CASE (14)
elmt = 'silicium' ; AtW = 34.855
CASE (18)
elmt = 'argon' ; AtW = 39.948
CASE (47)
elmt = 'argent' ; AtW = 107.868
CASE (54)
elmt = 'xenon' ; AtW = 131.29
CASE DEFAULT
elmt = non_utilise ; AtW = 0.
END SELECT element
III.C
LE CHOIX AVEC WHERE
Cette instruction ne sapplique quaux tableaux. Linstruction WHERE permet deffectuer un

choix, laide dun filtre, puis deffectuer des instructions uniquement aux lments filtrs. Ce bloc
ressemble beaucoup un bloc IF, mais il permet en plus une criture compacte pour les tableaux.
WHERE (expression_logique)
bloc1
ELSEWHERE
bloc2
END WHERE
Remarque: Les blocs dinstructions bloc1 et bloc2 ne peuvent agir que sur des affectations
concernant des tableaux. Dans le membre de droite des instructions, les tableaux sont obligatoirement
conformant avec celui de lexpression logique.
WHERE (tab1 > 0.)

tab2 = SQRT (tab1)
ELSEWHERE
tab2 = 0.
END WHERE
28
En Fortran 95, la syntaxe dun bloc WHERE stend grce lajout de filtre de choix logique
ELSEWHERE(filtre), de faon identique au bloc IF, ELSE IF, ELSE, END IF; de plus il peut tre
tiquet comme les structures prcdentes. Le bloc WHERE scrit alors sous la forme suivante:
[nom:] WHERE (expression_logique1)

bloc1
ELSEWHERE (expression_logique2)
bloc2
ELSEWHERE
bloc3
END WHERE [nom]
III.D
LA BOUCLE DO
Trs souvent en programmation, nous avons besoin de reproduire un grand nombre de fois les
mmes instructions. La boucle DO sert alors itrer.
[nom:] DO [bloc de contrle]

bloc
END DO [nom]
III.D.1
Clause de contrle itrative
Si davance, on sait combien de fois, on a besoin de faire la mme srie doprations, on utilise un
compteur entier.
[nom:] DO compt = int1, int2 [, int3]

bloc
END DO [nom]
O
int1 est la valeur entire de dpart du compteur;

int2 est la valeur entire darrive;
int3 est lincrment entier, par dfaut il vaut 1 et est donc optionnel;
et compt est une variable entire qui prendra les valeurs de int1 int2, en ajoutant int3
chaque fois. Bien entendu, la dernire itration ne tombe pas forcment sur la valeur de int2.
Le nombre ditrations est le plus grand nombre entre (int2 + int3 int1) / int3 et 0.
Exemple III.4
DO num = 1, 300
T(num) = dx * num + y
END DO
29
Attention: num = 4 en fin de boucle!

Exemple III.5
alenvers: DO i = 201, 2, -1
ux = (i - 1) * 5.e-3
Tx = FUNTEMP (u1, ux, T1, Tx, GT)
fonction
RT = FUNREST (u1, ux, T1, Tx, GT)
fonction
PRINT*, ux, Tx, RT
END DO alenvers
III.D.2
! appel de
! appel de
Clause de contrle WHILE
Dans ce cas, on ne connat pas davance le nombre ditrations, mais on connat plutt un domaine
dans lequel on veut que la srie de calculs soit excut. Ce domaine est dfini par une expression
logique et litration continue tant que cette expression est VRAIE.
Structure gnrale de la boucle DO WHILE:
[nom:] DO WHILE (expression_logique)

bloc
END DO [nom]
Exemple III.6
Integre_choc : DO WHILE (n < nstep)

rr = f(1,1) * r1 ; TT = f(3,1) * T1
CALL RUNGEKUTTA (z, h, f, 3, n, Gas)
n = z / h
END DO Integre_choc
Cette clause de contrle est assez souvent utilise pour lire les donnes dun fichier dont on ne sait
pas le nombre denregistrement. On utilise pour cela le marqueur de fin de fichier eof, associ au
paramtre iostat. Nous verrons plus loin, avec les accs de fichiers et les entres-sorties, comment
on procde. Mais le boucle prend la forme suivante:
Exemple III.7
DO WHILE (eof == 0)
READ (unit=65, iostat=eof), x, y, z
END DO
30
III.D.3
Boucle infinie et altration
On peut aussi construire des boucles, qui sont priori infinies, mais dans laquelle on insre une
clause de sortie. Bien entendu, aucune boucle infinie nest concevable, il faut linterrompre par un
moyen ou un autre.
Pour cela on utilise linstruction EXIT:

bloc
IF (expression_logique) EXIT [nom]
END DO [nom]
Pour altrer le droulement dune boucle, il est possible de forcer lexcution du programme
passer la boucle suivante, avec linstruction CYCLE.

bloc1
IF (expression_logique) CYCLE [nom]
bloc2
END DO [nom]
III.E
LE SCHMA FORALL
Dun point de vue algorithmique, le schma FORALL remplace certaines boucles DO. Mais pour
le compilateur, il facilite la paralllisation de cette partie de code. La syntaxe du schma FORALL est la
suivante:
[nom:] FORALL (bloc de contrle [, bloc de contrle]

[, filtre])
bloc
END FORALL [nom]
Le bloc de contrle est une commande sur les indices dun ou plusieurs tableaux. Si plusieurs
plages dindices sont dfinies laide de plusieurs blocs de contrle, le domaine doit tre rectangulaire.
Cest--dire que chaque commande sur les indices ne doit pas dpendre des autres indices. La
construction des tableaux, ainsi que leur manipulation est dtaille dans le chapitre suivant.
Exemple III.8
FORALL (i=3:10, j=2:5) mat(i,j) = 12

Exemple III.9
FORALL (i=1:n, j=1:m, mat1>0)

mat2(i,j) = log(mat1(i,j))
END FORALL
31
IV
IV.A
LES TABLEAUX
GESTION MMOIRE DES TABLEAUX
Un tableau est un ensemble d'lments ayant mme type et mme valeur de paramtre de soustype. Il est dfini par son type, son rang, ses tendues, son profil, sa taille. Un tableau peut contenir
jusqu' 7 dimensions.
Le rang (rank) d'un tableau est son nombre de dimensions.

L'tendue du tableau dans une dimension est le nombre d'lments dans cette dimension.
Le profil (shape) d'un tableau est un vecteur de rang 1 et d'tendue le rang du tableau et dont
chaque lment contient l'tendue dans la dimension correspondante.
La taille (size) du tableau est le produit des tendues sur toutes les dimensions.
Deux tableaux de mme profil sont dits conformant.

Dans le chapitre II.D, nous avons voqu la dclaration des tableaux. Distinguons les tableaux qui
ont une allocation statique de ceux qui ont une allocation dynamique.
IV.A.1
Lallocation statique
Il suffit de prciser le type du tableau, puis l'attribut dimension lors de la dclaration en indiquant
uniquement l'tendue de chaque dimension.
type, DIMENSION (b_inf1:b_sup1, b_inf2:b_sup2)::nom_tab

O b_inf1, b_sup1 sont des entiers qui dlimitent ltendue de la premire dimension du tableau
nom_tab. Il sont respectivement lindice minimum et lindice maximum. Il en va de mme pour la
seconde dimension avec les entiers b_inf2, b_sup2.
IV.A.2
Lallocation dynamique
On parle dallocation dynamique lorsque lon a pas dfini au pralable ltendue du tableau. Il se
peut, en effet, que cette donne ne soit pas connue lors de lcriture du programme, par contre elle le
deviendra pendant lexcution du programme. Ce phnomne est frquemment rencontr lorsquon lit
des donnes dans un fichier gnr par un autre programme. En Fortran 90, nous avons alors la
possibilit de grer de faon dynamique la mmoire alloue un tableau. Il existe pour cela deux
manires distinctes: soit le passage en argument dun tableau, et de sa dimension, dans une procdure,
soit lallocation directe de mmoire.
32
La diffrence principale entre ces deux mthodes est que:

dans la premire, lemplacement mmoire des tableaux est allou ds lentre dans la
procdure et est libr sa sortie;
dans la seconde cest le dveloppeur qui dcide du moment de lallocation et du moment de la
libration de la mmoire.
a) En argument de procdure: les tableaux automatiques

Ce cas se prsente lorsque au moment du dveloppement dune procdure, on ne connat pas
encore la dimension du tableau, mais le programme appelant cette routine sera capable den fournir la
valeur. Ou bien lorsque le mme sous-programme est appel tre excut, avec des tableaux de tailles
trs diffrentes.
Avec passage en argument de la taille, la syntaxe gnrale se prsente sous la forme suivante:
SUBROUTINE nom (arg1, n1, arg2, n2 )

IMPLICIT NONE
INTEGER :: n1, n2
type, DIMENSION (n1) :: arg1
type, DIMENSION (n2) :: arg2
Sans passage de la taille en argument, la syntaxe gnrale se prsente sous la forme suivante:
SUBROUTINE nom (arg1, arg2, )

IMPLICIT NONE
type, DIMENSION (:) :: arg1
type, DIMENSION (:) :: arg2
Pour connatre ltendue des tableaux, on a recourt linstruction SIZE. Mais, dans ce cas,
lutilisation dune interface explicite est obligatoire, sinon le compilateur ne peut pas dtecter des
erreurs potentielles dans la manipulation de ces tableaux. Nous reviendrons sur ce point lorsque nous
verrons la notion dINTERFACE.
b) Avec linstruction ALLOCATE: les tableaux dynamiques

Pour gnrer dynamiquement des tableaux et librer la mmoire au moment opportun, Fortran 90
possde linstruction ALLOCATE et DEALLOCATE. Au pralable, le tableau considr devra tre
dclar avec lattribut ALLOCATABLE.
33
La forme gnrale a lallure suivante:
type, DIMENSION(:[,]), ALLOCATABLE :: nom_tab

INTEGER :: ok
ALLOCATE (nom_tab(dim1[,]) [, stat = ok])

[bloc_instructions]
DEALLOCATE (nom_tab [, stat = ok])
Lutilisation du paramtre stat est optionnel, cest un contrle du bon droulement de lallocation
ou de la libration de la mmoire. Lorsque lallocation (ou la libration) sest correctement effectue,
linstruction ALLOCATE (ou DEALLOCATE) renvoie pour la variable entire ok la valeur 0, sinon ok
prend une valeur suprieure 0.
Exemple IV.1
SUBROUTINE SOLVER
IMPLICIT NONE
INTEGER :: npas
REAL, ALLOCATABLE, DIMENSION(:) :: Prad, Frad
ALLOCATE (Prad(npas), Frad(npas), stat = ok)
IF (ok > 0) THEN
PRINT*,"Il y a un probleme d'allocation dans
SOLVER"
STOP
END IF
READ (18,*) Prad, Frad
DEALLOCATE (Prad, Frad)

END SUBROUTINE SOLVER
Il existe en plus une fonction qui permet de sassurer que la mmoire du tableau que lon manipule
est alloue ou non:
allocated (array)
Elle renvoie la valeur logique .TRUE. si le tableau allouable array est allou, sinon la valeur
.FALSE..
34
IV.B
LA MANIPULATION DES TABLEAUX

a) Gnralits
Fortran 90 permet la manipulation globale des tableaux, ou de section de tableaux, en indiquant

seulement leur nom. Cependant les tableaux doivent tre conformants pour tre utiliss dans les mmes
instructions. Tous les oprateurs utiliss avec des variables scalaires sont alors utilisables avec des
tableaux.
Linitialisation dun tableau au moment de sa dclaration est permise laide dun constructeur de
tableaux. Cest un vecteur de scalaires born par les signes (/ et /) .
Remarque importe: la valeur dune expression faisant intervenir un tableau est entirement
value avant son affectation.
b) Globale
Attention toutefois la simplicit de lcriture, car bien quelle allge les lignes de programme, il
ne faut pas oublier que derrire un simple identifiant peut se cacher un tableau monstrueux! Dun autre
ct, cette criture compacte fait ressortir lessentiel de la programmation et vite bien des erreurs sur
les bornes et dimensions de tableaux.
Exemple IV.2
REAL, DIMENSION(4) :: tab
tab = 100.
Chacun des 4 lments du tableau tab prend la valeur 100.
Exemple IV.3
REAL, DIMENSION(4) :: tab1, tab2, tab3
tab1 = 100.
tab2 = 2 + tab1
Chacun des 4 lments du tableau tab2 prend la valeur 102.
Exemple IV.4
INTEGER :: i
REAL, DIMENSION(4) :: tab1, tab2=(/1,2,3,4)/)
tab1 = (/10.,15.,20.,25./)
tab2 = tab2 * tab1
Chacun des 4 lments du tableau tab2 prend respectivement la valeur 10; 30; 60; 100.
35
Exemple IV.5
INTEGER :: i
REAL, DIMENSION(4) :: tab1, tab2=(/ (i, i=1,4)/)
tab1 = 100. ; tab2 = tab2 * tab1

Chacun des 4 lments du tableau tab2 prend respectivement la valeur 100; 200; 300; 400.
On peut aussi repr par le caractre : ltendue du tableau. La notation est alors plus lourde,
mais permet au dveloppeur de ne pas oublier quil manipule un tableau n dimension ce moment.
Pour reprendre lexemple prcdent, on peut crire sous la forme suivante.
Exemple IV.6
INTEGER :: i
REAL, DIMENSION(4) :: tab1, tab2=(/ (i, i=1,4)/)
tab1(:) = 100. ; tab2(:) = tab2(:) * tab1(:)

Dans le cas de tableau plusieurs dimension, on mentionnera chacune des dimensions par :.
REAL, DIMENSION(4,16) :: tab1, tab2
tab2(:) = 20. / tab1(:,:)

c)
Par section
On peut aussi faire rfrence une partie d'un tableau appele section de tableau. Le sous-tableau
ainsi dfini est aussi un tableau.
Les indices sont donns soit par une suite arithmtique lorsqu'on a une section rgulire du tableau
initial, soit par un vecteur dindices, lorsquon veut extraire une section non rgulire.
La section rgulire prend une forme typique: b_inf: b_sup: inc
O b_inf et b_sup sont respectivement les indices infrieure et suprieure de la section choisie, et
inc est un entier qui reprsente lincrment. Par dfaut inc vaut 1. Cest le mme principe que dans la
boucle DO avec clause itrative.
Exemple IV.7
INTEGER :: i
REAL, DIMENSION(20) :: tab1 = (/ (i, i=1,20)/)
REAL, DIMENSION(5) ::
tab2(:) = tab1(1:20:4)
36
De plus, on peut combiner les diffrentes manipulations possibles, en voici un certain nombre
dexemples.
Exemple IV.8
! on slectionne les lments de la ligne 2

!
et des colonnes de 4 8
tab1(2,4:8)
! on slectionne tous les lments de la ligne 2
tab1(2,:)
! on slectionne tous les lments des lignes 1, 2 et 3
tab1(:3,:)
! on slectionne les lments des lignes 1, 3 et 5
!
et des colonnes de 4 n
tab1(1:6:2,4:n)
La section quelconque prend la forme dun vecteur dindices: (/i1, i2, i3/), a laide du
constructeur de vecteurs.
Exemple IV.9
! on slectionne les lments des lignes 1, 5 et 19

!
et des colonnes de 4, 5 et 10
tab1((/1,5,19/), (/4,5,10/))
On peut aussi affecter directement une section avec lidentifiant dun vecteur.
Exemple IV.10
INTEGER, DIMENSION(4) :: vect_ind = (/3,6,7,9/)

tab1(vect_ind, (/4,5,10/))
Lorsquun sous-tableau est constitu dlments rpts, il ne peut pas recevoir une nouvelle
affectation, donc il ne peut tre plac gauche dune expression.
Exemple IV.11
INTEGER, DIMENSION(4) :: vect_ind = (/3,6,3,9/)

INTEGER, DIMENSION(10) :: tab1
INTEGER, DIMENSION(4) :: tab2
! on peut ecrire :
tab2 = tab1(vect_ind)
! mais il est interdit dcrire :
tab1(vect_ind) =
37
IV.C
LES FONCTIONS INTRINSQUES SUR LES TABLEAUX
Fortran 90 propose toute une gamme de fonctions intrinsques qui offre lavantage de simplifier
lutilisation des tableaux. Nous distinguerons les fonctions passives qui renvoient seulement une
information sur le tableau des fonctions actives qui modifient le tableau.
Dans la suite, on utilisera comme argument les mots suivants:
array qui dsigne le tableau sur lequel on applique la fonction;
vect qui dsigne un vecteur;
mask qui dsigne un tableau dexpressions logiques conformant au tableau array;
dim qui restreint la fonction sappliquer la dimension mentionne.
IV.C.1
Les fonctions dinterrogation
maxloc (array [, mask] [, dim])

minloc (array [, mask] [, dim])
Ces fonctions retournent respectivement un tableau de rang 1 correspondant la position de
llment maximum et de llment minimum du tableau array. Fortran 95 admet en plus la prcision
de la dimension dim, ce que ne fait pas Fortran 90.
lbound (array [, dim])

ubound (array [, dim])
Ces fonctions retournent respectivement un tableau d'entiers du type par dfaut et de rang 1 qui
contient la liste des bornes infrieures du tableau array (ou de la dimension dim mentionne) et la liste
des bornes suprieures du tableau array (ou de la dimension dim mentionne).
size (array [, dim])

Cette fonction retourne la taille totale du tableau array ou l'tendue le long de la dimension dim.
shape(array)
Cette fonction retourne un tableau d'entiers de rang 1 qui contient le profil du tableau array.
Exemple IV.12
INTEGER, DIMENSION(-1:1,3) :: tab1

15 2 35
tab1= 4 50 36
7 28 9
38
maxloc (tab1)
minloc (tab1)
lbound (tab1)
ubound (tab1)
size (tab1)
shape(tab1)
donne
donne
donne
donne
donne
donne
(/2, 2/)
(/2, 3/)
(/-1, 1/)
(/1, 3/)
9
(/3, 3/)
allocated (array)
Cette fonction fournit la valeur .TRUE. si le tableau array, dclar avec allocatable, est allou
et la valeur .FALSE. sinon.
IV.C.2
Les fonctions de rduction
Les fonctions de rduction renvoient soit un scalaire soit un tableau dun rang infrieur celui
pass en argument.
a) Les fonctions all et any

all (mask [, dim])
Cette fonction renvoie la valeur logique .TRUE., si tous les lments, pris un par un, rpondent
aux critres du masque, sinon la valeur .FALSE.. Si dim est prcis, la fonction renvoie un tableau
qui contient les valeurs logiques .TRUE. ou .FALSE. suivant que les lments de cette
dimension rpondent aux critres du masque.
Exemple IV.13
tab1(1,:) = (/1, 3, 5, 7/) ; tab2(1,:) = (/1, 2, 3, 4/)

tab1(2,:) = (/2, 4, 6, 8/) ; tab2(2,:) = (/5, 6, 7, 8/)
! reduction globale
ALL (tab1==tab2)
donne .false.
ALL (tab1/=tab2)
donne .false.
! reduction par colonne
ALL (tab1/=tab2, dim = 1)
donne /(.false., .true., .true., .false./)
! reduction par ligne
donne /(.false., .false./)
Si on a dj des tableaux de variables logiques, on les utiliser directement dans linstruction ALL.
39
Exemple IV.14
tab1(1,:) = (/.true., .true., .true., .true./)

ALL (tab1) donne .true.
On peut aussi tester les valeurs dun tableau.
Exemple IV.15
REAL, DIMENSION (5,10) :: tab1, tab2
IF (ALL(tab1) >= 0) THEN

tab2 = SQRT (tab1)
END IF
De faon symtrique la fonction all, on peut utiliser la fonction suivante:
any (mask [, dim])

Cette fonction renvoie la valeur logique .TRUE., si au moins un des lments, pris un par un,
rpondent aux critres du masque, sinon la valeur .FALSE.. Si dim est prcis, la fonction renvoie
un tableau qui contient les valeurs logiques .TRUE. ou .FALSE. suivant que les lments de
cette dimension rpondent aux critres du masque.
Exemple IV.16
tab1(1,:) = (/1, 3, 5, 7/) ; tab2(1,:) = (/1, 2, 3, 7/)

tab1(2,:) = (/2, 4, 6, 8/) ; tab2(2,:) = (/5, 6, 4, 8/)
! reduction globale
ANY (tab1==tab2)
donne .true.
ALL (tab1/=tab2)
donne .true.
! reduction par colonne
donne /(.true., .true., .true., .false./)
! reduction par ligne
donne /(.true., .true./)
Exemple IV.17
tab1(1,:) = (/.true., .true., .false., .true./)

ANY (tab1) donne .true.
On peut aussi tester les valeurs dun tableau.
40
Exemple IV.18
REAL, DIMENSION (5,10) :: tab1, tab2
IF (ANY(tab1) <= 0) THEN

PRINT*, On ne peut pas calculer la racine carree.
EXIT
END IF
b) La fonction count
count(mask [, dim])
Cette fonction compte le nombre doccurrences qui prennent la valeur logique .TRUE., suivant
les critres du masque. Si dim est prcis, la fonction renvoie un tableau dentiers contenant le nombre
doccurrences VRAI.
Exemple IV.19
tab1(1,:) = (/1, 3, 5, 7/) ; tab2(1,:) = (/1, 2, 3, 7/)

tab1(2,:) = (/2, 4, 6, 8/) ; tab2(2,:) = (/5, 6, 4, 8/)
! compte global
COUNT (tab1==tab2)
donne 3
COUNT (tab1/=tab2)
donne 5
! compte par colonne
COUNT (tab1/=tab2, dim = 1)
donne /(1, 2, 2, 0/)
! compte par ligne
COUNT (tab1/=tab2, dim = 2)
donne /(2, 3/)
Exemple IV.20
tab1(1,:) = (/.true., .true., .false., .true./)

COUNT (tab1)
donne 3
c) Les fonctions maxval et minval
maxval (array [, dim] [, mask])
minval (array [, dim] [, mask])
Ces fonctions renvoient respectivement la valeur maximum et la valeur minimum du tableau
array, ou le tableau des maxima et des minima suivant la dimension du tableau impose et selon les
critres du masque sil est prcis.
Note: Si le tableau est de taille nulle, le rsultat est respectivement le plus grand nombre positif et
ngatif disponible sur l'ordinateur.
41
Exemple IV.21
tab1(1,:) = (/1, 3, 5, 7/) ; tab2(1,:) = (/1, 2, 3, 7/)

tab1(2,:) = (/2, 4, 6, 8/) ; tab2(2,:) = (/5, 6, 4, 8/)
! reduction globale
MAXVAL (tab1)
donne 8
! reduction partielle, par colonne
MINVAL (tab1,DIM=1,MASK=tab1>1) donne (/2, 3, 5, 7/)
d) Les fonctions sum et product
sum (array [, dim] [, mask])
product (array [, dim] [, mask])
Ces fonctions calculent respectivement la somme et le produit des lments d'un tableau de
nombres; ou suivant la dimension indique et selon les critres du masque, sil est prcis.
Note: Si le tableau est de taille nulle, le rsultat est respectivement 0 et 1.
Exemple IV.22
1 3 5 7
tab1=
2 4 6 8
1 2 3 7
et tab2=
5 6 4 8
SUM(tab1)
PRODUCT(tab1, MASK=tab1<6)
SUM(tab2, DIM=2)
PRODUCT(tab2, DIM=2, MASK=tab2>4)
IV.C.3
donne
donne
donne
donne
36
120
(/13, 23/)
(/7, 240/)
Les fonctions de construction et de transformation
a) La fonction merge
merge (array1, array2, mask)
Cette fonction fabrique un tableau, partir des deux tableaux conformants et de mme type array1
et array2, en fonction des critres imposs par le masque. Si la valeur du masque est vrai, on utilise
llment de array1, si la valeur du masque est faux on utilise llment de array2.
Exemple IV.23
1 2 3
tab1= 4 5 6
7 8 9
10 20 30
et tab2= 40 50 60
70 80 90
MERGE (tab1, tab2, tab1>4)

donne
42
10 20 30
tab1= 40 5 6
7 8 9
b) La fonction reshape
reshape (array, shape [, pad] [, order]))
Cette fonction construit un tableau, partir des lments du tableau array, et dont le profil est
donn par le tableau d'entiers positifs de rang 1 shape. Lattribut optionnel pad est un tableau du mme
type de array, dont les lments seront utiliss si la taille de shape est suprieure celle de array.
Exemple IV.24
RESHAPE ( (/(i, i=1,12)/), (/3, 4/))

1 4 7 10
donne 2 5 8 11
3 6 9 12
c) Les fonctions pack et unpack
pack (array, mask [, vector])
Cette fonction construit un tableau de rang 1, en compressant les valeurs du tableau array, suivant
les critres du masque. Si le vecteur optionnel vector est prsent, le rsultat aura la taille de vector.
unpack (vector, mask [, field])

Cette fonction est assez symtrique de la prcdente. Elle construit un tableau de rang suprieur
1, en dcompressant les valeurs du vecteur vector, suivant les critres du masque. Si le tableau optionnel
field est prsent, les valeurs de field, qui sont du mme type que celle de vector, seront utilises lorsque
le masque contient une valeur fausse. Le rsultat aura le profil du masque et le type du vecteur.
Exemple IV.25
1 4 7 10
On a tab1= 2 5 8 11
3 6 9 12
vect1 = (/ (i, i=-12,-1) /)
PACK (tab1, MASK=tab1<10, VECTOR=vect1)
donne
(/1, 2, 3, 4, 5, 6, 7, 8, 9, -3, -2, -1 /)
d) La fonction spread
spread (array, dim, n)
Cette fonction cre un nouveau tableau en dupliquant n fois les valeurs du tableau array, le long de
la dimension mentionne. Le rsultat est un tableau dun rang suprieur array.
e) Les fonctions cshift et eoshift

cshift (array, shift [, dim])
Cette fonction opre un dcalage circulaire sur les lments du tableau array, le long de la
dimension indique, dautant dindices que shift indique.
43
Attention: shift est un entier positif, pour un dcalage vers les indices dcroissants (on effectue i =
i-shift), ou un entier ngatifs, pour un dcalage vers les indices croissants. Par dfaut dim est 1.
eoshift (array, shift [, boundary] [, dim])

Cette fonction agit comme la prcdente, mais donne en plus la possibilit de remplacer les
lments perdus la frontire par des lments de remplissage donns par le tableau boundary.
Note: Si boundary nest pas prsent, les valeurs de remplissage par dfaut dpendent du type du
tableau array:
pour un INTEGER, la valeur par dfaut est
0;
pour un REAL,
"
"
0.0;
pour un COMPLEX,
"
"
(0.0,0.0);
pour un LOGICAL,
"
"
.FALSE.;
pour un CHARACTER,
"
"
un chane compose de blancs.
Exemple IV.26
1 4 7 10
On a tab1= 2 5 8 11
3 6 9 12
CSHIFT (tab1, SHIFT=2, DIM=1)
donne
3 6 9 12
1 4 7 10
2 5 8 11
EOSHIFT (tab1, SHIFT=-1, DIM=2)

donne
IV.C.4
Les fonctions propres aux matrices et vecteurs

a) Multiplication de vecteurs et de matrices
Pour effectuer le produit scalaire de deux vecteurs:
dot_product (vect1, vect2)

et la multiplication de deux matrices:
matmul (mata, matb)
44
0 1 4 7
0 2 5 8
0 3 6 9
b) matrice transpose
transpose (matrix)
Cette fonction renvoie la matrice transpose du tableau matrix.
45
V.A
LES POINTEURS
INTRODUCTION
V.A.1
Dfinition:
Le pointeur est un objet qui peut dsigner des objets diffrents au cours de l'excution d'un
programme, il reoit lattribut POINTER. Il agit comme un alias et est du mme type que les objets
quil pointe. L'objet dsign par le pointeur est appel la cible du pointeur, il doit recevoir lattribut
TARGET. Pour assigner un objet un pointeur, on utilise le symbole de la double flche matrialise
pas les caractres: =>. Un pointeur a aussi le droit dtre valoriser vers un autre pointeur.
La notion de pointeur est surtout utile dans le contexte de lallocation dynamique de mmoire.
V.A.2
Dclaration dun pointeur et dune cible

REAL, TARGET:: targ
REAL, POINTER:: ptr
Le type, le paramtre de type et le rang du pointeur et de la cible doivent tre identiques.

Et pour affecter targ comme cible de ptr (ou pour valoriser le pointeur): ptr => targ.
Remarque: pour dclarer un tableau de pointeurs, seul son rang (le nombre de dimensions) doit
tre dclar et ses bornes prendront les valeurs de l'objet point.
Exemple V.1
REAL, POINTER :: ptr1

INTEGER, DIMENSION(:,:), POINTER :: ptr2
! attention ptr3 nest pas un tableau de pointeurs.
COMPLEX, POINTER :: ptr3(:)
V.B
TAT DUN POINTEUR
Un pointeur se trouve forcment dans un des trois tats suivants:

indfini: comme lors de sa dclaration,
nul: il ne pointe sur rien, cest--dire quil nest pas lalias dune variable,
ou associ: il pointe sur une variable.
46
Note: en Fortran 95, on peut forcer un pointeur ltat nul, lors de sa dclaration.
REAL, POINTER:: ptr => NULL()

a) La fonction nullify
Linstruction NULLIFY permet de forcer un pointeur ltat nul.
syntaxe: NULLIFY (ptr1)

! norme 95 : remplacee par la valorisation
ptr1 => NULL()
b) La fonction associated
Ltat dun pointeur peut tre connu grce la fonction intrinsque ASSOCIATED, dont la
syntaxe gnrale est la suivante:
associated (pointer [, pointer] [, target])

associated (pointer)
Cette fonction renvoie .TRUE., si pointer est associ une cible, sil est dans ltat nul, la
fonction renvoie FALSE..
associated (pointer1, pointer2)

Cette fonction renvoie .TRUE., si pointer1 et pointer2 sont associs la mme cible, sinon elle
renvoie FALSE.. Remarque: si pointer1 et pointer2 sont tous les deux dans ltat nul, elle renvoie
FALSE..
associated (pointer, target)

Cette fonction renvoie .TRUE., si pointer est associ la cible target, sinon elle renvoie
FALSE..
Attention: le pointeur ne doit pas tre dans ltat indtermin pour utiliser cette fonction!
c)
Opration sur les pointeurs
On a vu que loprateur => sert valoriser le pointeur. Le pointeur prend alors la valeur de la
cible.
Loprateur = sert affecter une valeur, mais attention lorsque les oprandes sont des
pointeurs, laffectation porte sur la cible et non sur le pointeur.
47
V.C
LALLOCATION DYNAMIQUE
Linstruction ALLOCATE, que nous avons dj vu pour lallocation dynamique de mmoire des
tableaux, sert aussi associer un pointeur et lui allouer de la mmoire. Linstruction DEALLOCATE
sert librer la mmoire, comme pour un tableau.
Notes:
Dans ce cas, lespace allou na pas de nom et la seule faon dy accder est dutiliser le
pointeur. Le pointeur est lalias direct du chemin qui mne cette mmoire.
Aprs linstruction DEALLOCATE, le pointeur est dans ltat nul.
On ne peut pas excuter linstruction DEALLOCATE sur un pointeur dont ltat est
indtermin.
On peut aussi faire de lallocation dynamique de mmoire pour des variables, par
lintermdiaire de pointeurs.
Exemple V.2: tri de chane de caractres
MODULE CHAINE
END MODULE CHAINE
PROGRAM TRI_CHAINE
IMPLICIT NONE
CHARACTER (LEN=80), DIMENSION(:), TARGET :: chaine
CHARACTER (LEN=80), DIMENSION(:), POINTER :: ptr_ch
CHARACTER (LEN=80), POINTER :: ptr_int
INTEGER :: num, i
LOGICAL :: fini
PRINT*, Quel est le nombre de chaines ?
READ(*,*) num
ALLOCATE(chaine(num), ptr_ch(num))
lis : DO i = 1, num
PRINT*, Donnez votre message :
READ(*,*) chaine(i)
ptr_ch(i) => chaine(i)
END DO
48
tri_tous : DO
fini = .TRUE.
tri_chacun : DO i = 1, num-1
IF (chaine(i) > chaine(i+1)) THEN
fini = .FALSE.
ptr_int
=> ptr_ch(i)
ptr_ch(i)
=> ptr_ch(i+1)
ptr_ch(i+1) => ptr_int
END IF
END DO tri_chacun
IF (fini) EXIT
END DO tri_tous
END PROGRAM TRI_CHAINE
Dans lexemple prcdent, on aurait pu faire le mme tri laide dun tableau ALLOCATABLE,
la place du tableau de pointeurs. Nanmoins, il parat que le temps dexcution dun programme est
amlior dans le cas de tableaux de grandes tailles et de longues chanes de caractres! Car la gestion
de la mmoire diffre dans ces deux cas.
V.C.1
En argument de procdure
Il est possible de passer en argument de procdures un pointeur. Nous distinguons le cas o le

pointeur est dj dans la dfinition de la procdure, du cas o largument muet nest pas un pointeur.
a) Largument muet a lattribut pointer

Dans ce cas, le pointeur figure obligatoirement dans lappel de la procdure et nest pas forcment
associ au moment de lappel. Linformation relle qui passe dans la procdure est le descripteur du
pointeur: cest--dire son adresse, ses dimensions
Remarques:
Linterface doit tre explicite, pour que le compilateur sache que la procdure possde en
argument muet un pointeur.
Lattribut intent ne peut pas tre utilis pour qualifier le pointeur qui est en argument muet.
b) Largument muet na pas lattribut pointer

Dans ce cas, le pointeur est obligatoirement associ avant lappel de la procdure. Cest alors
linformation concernant la cible qui passe dans la procdure, cest--dire son adresse. On se retrouve
alors dans un cas habituel de passage de variables dans un appel de procdure.
49
c)
Cible en argument de procdure
Si un argument en appel de procdure a l'attribut TARGET, tout pointeur l'ayant pour cible au
moment de lappel, devient indfini au retour de la procdure. De faon gnrale, la norme ne garantit
pas la conservation de lassociation du pointeur entre sa cible passe en argument dappel de procdure
et la cible correspondante en argument muet.
50
51
VI
VI.A
CONTRLE DE VISIBILIT
LES RESSOURCES PRIVES ET PUBLIQUES
Il est souvent souhaitable que lintgralit des ressources dun module ne soit pas accessible par
les autres units de programme. En effet, lorsquon dfinit un module, on souhaite faire partager un
certain nombre de variables, de dfinitions de type, de procdures, via linstruction use nom_module;
mais pour des besoins spcifiques ce module, on est en droit de dfinir des ressources propres ce
module.
Les ressources non visibles depuis lextrieur sont dites prives (private).
Tandis que les ressources visibles depuis lextrieur sont dites publiques (public).
Par dfaut, toutes les ressources dun module sont publiques.

On a souvent intrt rendre prives certaines ressources dun module, cela vite les risques de
conflits avec les ressources dun autre module.
Une autre faon de restreindre lutilisation des ressources dun module est dinsrer linstruction
only nom_var, lors de laccs un module, dans linstruction use nom_module (voir plus haut
chapitreII.A.3a)).
a) Les instructions PUBLIC et PRIVATE

Le mode par dfaut est le mode public. Les instructions PUBLIC et PRIVATE, sans argument,
permettent de changer le mode. Un telle instruction ne peut apparatre quune seule fois dans un
module et affecte lensemble du module.
MODULE PARAM
IMPLICIT NONE
INTEGER, DIMENSION(:) :: par
PRIVATE
! tout le module devient priv.
REAL :: x, y
INTEGER :: i, j
END MODULE PARAM
b) Les attributs PUBLIC et PRIVATE
Si lon veut rendre public ou priv nimporte quel objet dun module (ou dune procdure), on lui
affecte soit lattribut PUBLIC ou soit lattribut PRIVATE, directement lors de sa dclaration.
52
Syntaxe gnrale:
type, private:: var

type, public :: var
Attention toutefois ne pas confondre le fonctionnement des attributs PRIVATE et PUBLIC, avec
celui des instructions PRIVATE et PUBLIC, malgr leur similitude.
MODULE INIT
IMPLICIT NONE
PRIVATE
! rend lenvironnement priv.
REAL :: x, y
INTEGER :: i, j
REAL, DIMENSION(:), PUBLIC :: vect
! rend public le tableau vect, donc exportable.
PUBLIC :: lect
CONTAINS
SUBROUTINE lect (x,y)
! cette procdure est publique.

END SUBROUTINE lect
FUNCTION dict (vect)
! cette procdure est prive.

END FUNCTION dict
END MODULE INIT
VI.A.2
les types drivs semi-privs
On parle de type driv semi-priv lorsquun type driv, dfini au chapitre II.D.2, est public, mais
dont toutes les composantes sont prives. Son intrt est de permettre au dveloppeur de modifier la
structure du type driv, sans affecter les autres units de programme qui lutilisent.
Les attributs PUBLIC et PRIVATE s'appliquent aux types drivs, comme pour les autres types de
variables.
Alors un type driv est soit:
transparent: il est public et ses composantes sont aussi publiques;
semi-priv: il est public et ses composantes sont toutes prives;
ou priv.
53
Exemple VI.1
MODULE BASE
TYPE STAR
PRIVATE
INTEGER :: num
REAL, DIMENSION(:), POINTER:: lambda
END TYPE STAR
END MODULE BASE
Dans cet exemple, de dfinition dun type semi-priv, seules des procdures internes au module
base peuvent accder aux champs de la variable de type star.
Exemple VI.2
MODULE BASE
TYPE STAR
PRIVATE
INTEGER :: num
REAL, DIMENSION(:), POINTER:: lambda
END TYPE STAR
CONTAINS
FUNCTION VALOR(b1, b2)
IMPLICIT NONE
TYPE (STAR) :: b1, b2
b1%num = b2%num - 1
valor = (b1%lambda + b2%lambda) / 2.
END FUNCTION VALOR
END MODULE BASE
VI.A.3
Restriction de l'instruction USE
De la mme manire que lon peut rendre priv certaines ressources dun module, on peut limiter
laccs aux ressources dun module, lors de linstruction USE, dans lunit utilisatrice.
Syntaxe gnrale:
USE nom_module, ONLY: list_var
54
Exemple VI.3
MODULE PARAM
IMPLICIT NONE
REAL :: x, y
INTEGER :: i, j
END MODULE PARAM
PROGRAM MACHINE
USE PARAM, ONLY : x, y
! seules ces 2 variables sont accessibles
END PROGRAM MACHINE

Il est aussi possible de renommer des ressources dun module, si les noms proposs par le module
ne conviennent pas lunit utilisatrice: par exemple lorsquun de ces noms est dj affect! Pour
renommer, on utilise loprateur daffectation =>, identique celui des pointeurs.
Syntaxe gnrale:
USE nom_module, ONLY: old_var=>new_var, old_vec=>new_vec

Exemple VI.4
MODULE PARAM
IMPLICIT NONE
REAL :: x, y
INTEGER :: i, j
END MODULE PARAM
PROGRAM MACHINE
USE PARAM, ONLY : x=>varx, y=>vary
END PROGRAM MACHINE
55
VII
VII.A
CONTRLE DE COHRENCE
LES ARGUMENTS DE PROCDURE
VII.A.1 Vocation des arguments

Lors de la dclaration des arguments de procdure, il est possible daffiner le contrle sur la
manipulation de ces arguments, au cours de la procdure, en leur spcifiant une vocation:
tre un paramtre dentre seulement, donc ne pas recevoir de nouvelle affectation;
tre un paramtre de sortie seulement, donc recevoir certainement une affectation;
ou bien, tre la fois un paramtre dentre et de sortie de la procdure.
Pour spcifier cette vocation tre un paramtre dentre ou de sortie de procdure, on utilise
lattribut INTENT, qui peut tre in, out ou inout.
Syntaxe gnrale:
procedure nom_proc (arg1, arg2, , argn)

type, INTENT(in)
:: list_arg1
(et/ou)
type, INTENT(out)
:: list_arg2
(et/ou)
type, INTENT(inout) :: list_arg3
O list_arg1, list_arg2 et list_arg3 sont des listes de variables prises parmi les arguments de la
procdure.
Exemple VII.1
SUBROUTINE INIT (r1, u1, T1)

IMPLICIT NONE
REAL, INTENT(IN) :: r1, u1, T1
REAL :: Mach, Miso, Mrad, Mcon
56
! Calcul des constantes du systeme d'equations.

! gam = rapport des gaz parfaits gam = Cp / Cv.
gam = 5. / 3.
! Mach = Cshock / Csound = u1/Cs ; nombre de Mach
! adimensionne
Mach = u1 * sqrt(AtW/(gam*Rgaz*Tdeg*T1))
WRITE (6,*) "Le nombre de Mach est de ", Mach
gM2 = gam*Mach*Mach
! adimensionne
CvM2 = 1.5 / (Mach*Mach)
! adimensionne
! On a pose dans le calcul : w = (a T1**4) / (3 rho1 u1**2)
ww = 7.568e-15 * (T1*Tdeg)**4 / (3.*r1*u1*u1)
!
[erg/cm3]
! On a aussi pose : l = c/u1 /(Krossland*L), mais on en a
pas encore besoin.
Miso = sqrt((3.*gam-1.)/(gam*(3.-gam)))
PRINT*,"Le seuil isotherme est ", Miso
Mrad = 7**(7./6.) * (6*gam)**(-0.5) * (ww * gM2)**(1./6.)
PRINT*,"Le seuil radiatif est ", Mrad
Mcon = 2.38 * Mrad
PRINT*,"Le seuil continu est ", Mcon
END SUBROUTINE INIT
Dans lexemple prcdent, les arguments r1, u1 et T1 sont dclars avec lattribut INTENT(IN), la
procdure init ne peut donc pas modifier leur valeur. Il est interdit dcrire: r1=, u1=, ou
T1=.
57
Exemple VII.2
SUBROUTINE LECTURE (rr, uu, TT)

IMPLICIT NONE
REAL, INTENT(OUT) :: rr, uu, TT
! Lecture des conditions initiales.
OPEN (unit=12, file="condinit.dat", status="old",&
form="formatted")
READ(12,*)
READ(12,'(11x,e8.3)') rr
WRITE(6,*) 'Density in g/cm-3: ', rr
READ(12,'(11x,e8.3)') uu
WRITE(6,*) 'Shock speed in cm/s: ', uu
READ(12,'(11x,f7.3)') TT
WRITE(6,*) 'T in eV: ', TT
CLOSE (12)
END SUBROUTINE LECTURE
Dans lexemple prcdent, les arguments rr, uu et TT sont dclars avec lattribut intent(out), la
procdure lecture doit donc leur fournir une valeur.
Remarque: cependant, lexprience montre que le comportement du compilateur dpend aussi de
son constructeur: certain compilateur ne signale aucune erreur, ni mme message dattention, lors
dune mauvaise utilisation des variables vocation INTENT(OUT).
VII.A.2 Prsence optionnelle des arguments

L'attribut OPTIONAL permet de dclarer certains arguments comme optionnels et leur prsence
ventuelle est teste laide de la fonction intrinsque dinterrogation PRESENT. Cette prcaution vite
lutilisation systmatique de largument, or que lon sait pertinemment quil ne sera pas forcment
toujours prsent.
Syntaxe gnrale:
type, optional [, attributs] :: var
58
Exemple VII.3
SUBROUTINE LECTURE (rr, uu, TT, AtN)

IMPLICIT NONE
REAL, INTENT(OUT) :: rr, uu, TT
REAL, OPTIONAL, INTENT(OUT):: AtN
! Lecture des conditions initiales.
OPEN (unit=12, file="condinit.dat", status="old",&
form="formatted")
READ(12,*)
READ(12,'(11x,e8.3)') rr
WRITE(6,*) 'Density in g/cm-3: ', rr
READ(12,'(11x,e8.3)') uu
WRITE(6,*) 'Shock speed in cm/s: ', uu
READ(12,'(11x,f7.3)') TT
WRITE(6,*) 'T in eV: ', TT
IF (PRESENT(AtN)) THEN
READ(12,'(11x,i2)')
AtN
WRITE(6,*)
'Atomic number: ', AtN
END IF
CLOSE (12)
END SUBROUTINE LECTURE
VII.A.3 Passage d'arguments par mots cls

Dans un appel de procdure, il devient possible de reprer les arguments, non plus par leur
position, mais aussi par le nom de largument correspondant dans linterface de procdure. Cet appel
par mot cl est trs pratique, surtout lorsque la liste des arguments contient des arguments optionnels. Il
est mme recommand d'utiliser les mot cls pour les arguments optionnels. Toutefois les arguments,
qui ne sont encore reprs uniquement par leur position, doivent obligatoirement figurer en tte de liste,
et seul le dernier pourra tre omis (sil est optionnel).
Exemple VII.4
REAL SUBROUTINE EVALDIM (a, b, n, min, max, prec)

REAL, INTENT (IN), DIMENSION(n) :: a, b
REAL, INTENT (OUT), OPTIONAL :: min, max, prec
END SUBROUTINE EVALDIM
59
! Appels corrects
CALL EVALDIM (x, y)
CALL EVALDIM (x, y, min=eps)
CALL EVALDIM (min=eps, max=hug, a=x, b=y)
CALL EVALDIM (min=eps, prec=mic, a=x, b=y)
CALL EVALDIM (x, y, eps, hug)
CALL EVALDIM (x, y, max=hug, prec=mic)
VII.B
INTERFACE DE PROCDURE
Une interface de procdure est constitue des informations ncessaires permettant la

communication entre plusieurs units de programmes. Ces informations sont:
le type de la procdure: function ou subroutine;
les arguments de la procdure (arguments formels), avec leur type et leurs attributs,
les proprits du rsultat dans le cas d'une fonction.
Par dfaut, on est dans le cas d'une interface implicite: les arguments affectifs de lappel de la
procdure sont dfinis dans lunit de programme appelant, et les arguments muets de la procdure sont
dfinis dans la procdure.
Dans le cas, dune procdure interne, la compilation de lunit appelante et de la procdure se
fait ensemble: il y a donc un contrle de cohrence. Cest donc une interface explicite, mais
qui limite la visibilit de la procdure, depuis lextrieur.
Dans le cas de procdures externes, la compilation de lunit appelante et de la procdure se
fait sparment et les arguments sont passs par adresse. Alors, le contrle de cohrence entre
arguments effectifs et arguments muet nexiste pas la compilation. De nombreuses erreurs,
lors de lexcution du programme, sont possibles et souvent difficiles dtectes.
Cest pourquoi, on a recours une interface explicite, laide dun bloc interface. Ainsi, le
compilateur connat toutes les informations ncessaires l'interface entre lunit appelante et la
procdure.
Syntaxe gnrale dun un bloc interface:
interface
procedure nom_procedure (list_arg)
bloc dclaratif de list_arg
end procedure nom_procedure
end interface
o le bloc dclaratif est une duplication de la partie dclarative de la procdure.
60
VII.B.1 Bloc interface dans lunit appelante

On crit directement le bloc interface au niveau du bloc dclaratif de lunit de programme qui
appelle la procdure externe concerne.
Exemple VII.5
PROGRAM CHOC
IMPLICIT NONE
REAL :: rr1, uu1, TT1, rr2, uu2, TT2
REAL, EXTERNAL :: FuncGas
INTERFACE
SUBROUTINE STRUCT (r1, u1, T1, r2, u2, T2, FuncGas, TG)
REAL, INTENT(IN) :: r1, u1, T1, r2, u2, T2
CHARACTER(LEN=2), INTENT(IN) :: TG
END SUBROUTINE STRUCT
END INTERFACE
CALL STRUCT (rr1, uu1, TT1, rr2, uu2, TT2, FuncGas,

GP)
END PROGRAM CHOC

IMPLICIT NONE
INTEGER, PARAMETER :: nvar = 3, nstep = 1e4
REAL, DIMENSION(nvar, 2) :: f
INTEGER :: n, i, j, k, jm, km, count
REAL :: rr, uu, TT, z, z0, h
61
Integre_choc : DO n = 1, nstep
rr = f(1,1) * r1 ; TT = f(3,1) * T1
IF (rr>rho(nmax) .or. TT>TeV(mmax) ) THEN
EXIT Integre_choc
END IF
CALL RUNGEKUTTA (z, h, f, 3, n, FuncGas)
END DO Integre_choc

Linconvnient, dans ce cas, est quil est ncessaire de dupliquer le bloc interface dans toutes les
units de programme appelant la procdure concerne. Or lintrt dune procdure externe, avec bloc
interface, est justement dtre utilisable, avec cohrence, par toute autre unit de programme. On
privilgiera alors lcriture du bloc interface au sein dun module.
VII.B.2 Bloc interface dans un module

Pour amliorer la fiabilit gnrale, on prfre insrer le mme bloc interface dans toutes les units
de programme faisant appel la procdure en question. On utilise le module, qui via l'instruction use
insrera le bloc interface dans lunit appelante.
A ce niveau, on a le choix entre deux voies:
crire un module dans le seul but de contenir le bloc interface;
crire un module qui contient la procdure externe: cest une excellente solution!
a) Module avec bloc interface

On reprend lexemple prcdent, mais la dclaration du bloc interface se fait grce un module,
nomm interhydro.
Exemple VII.6
MODULE INTERHYDRO
INTERFACE
SUBROUTINE STRUCT (r1, u1, T1, r2, u2, T2,&
FuncGas, TG)
END INTERFACE
END MODULE INTERHYDRO
62
PROGRAM CHOC
USE INTERHYDRO
! Insertion de linterface
IMPLICIT NONE

GP)
END PROGRAM CHOC

IMPLICIT NONE
rr = f(1,1) * r1 ; TT = f(3,1) * T1
EXIT Integre_choc
END IF
END DO Integre_choc

b) Module contenant la procdure
On reprend nouveau lexemple prcdent, mais cette fois-ci le module sert encapsuler la
procdure, qui devient une procdure interne au module grce au mot cl contains. Linterface de
procdure est connue vie linstruction use nom_module.
63
Exemple VII.7
MODULE INTERHYDRO
CONTAINS
IMPLICIT NONE
rr = f(1,1) * r1 ; TT = f(3,1) * T1
EXIT Integre_choc
END IF
END DO Integre_choc

END MODULE INTERHYDRO
PROGRAM CHOC
USE INTERHYDRO
! accs directe a la procdure
IMPLICIT NONE

GP)
END PROGRAM CHOC
64
VII.B.3 Rcapitulatif sur linterface explicite

a) Linterface explicite
Une interface de procdure est dite explicite dans les cinq cas suivants:
appel de procdures intrinsques: elles ont toujours des interfaces explicites:
appel de procdure interne;
prsence d'un bloc interface dans la procdure appelante,
accs au module, via linstruction use, contenant le bloc interface de la procdure externe;
accs au module, via linstruction use, contenant la procdure externe;
b) Linterface explicite obligatoire

Le long du cours, on a dj mentionn des cas o linterface doit tre explicite, sinon le
compilateur ne peut pas savoir si le programme est cohrent ou non. On rencontre dix situations de ce
type:
utilisation dune fonction valeur tableau,
utilisation dune fonction valeur pointeur,
utilisation dune fonction valeur chane de caractres dont la longueur est dtermine
dynamiquement,
utilisation dune procdure gnrique,
passage en argument dun tableau profil implicite,
argument formel avec l'attribut pointer ou target,
passage d'arguments mots cl,
argument optionnel,
surcharge ou dfinition d'un oprateur,
surcharge de l'oprateur d'affectation.
VII.C
INTERFACE GNRIQUE
Le bloc interface peut servir aussi regrouper une famille de procdure, sous un mme nom. La
procdure sera appele dans une unit de programme par son nom de famille, ou nom gnrique. La
procdure qui sera rellement utilise lors de lappel est choisie pas le compilateur en fonction des
instructions du bloc interface. Le bloc interface doit alors possder un nom, qui sera le nom gnrique
des procdures concernes.
65
Syntaxe gnrale:
interface nom_generique
procedure nom1 (list_arg1)
bloc declaratif de nom1
end procedure nom1
procedure nom2 (list_arg2)
bloc declaratif de nom2
end procedure nom2
procedure nomn (list_argn)

bloc declaratif de nomn
end procedure nomn
end interface
Note: en Fortran 95, on peut aussi nommer linstruction end interface:
end interface nom_generique

Exemple VII.8
INTERFACE moyenne
FUNCTION moy_int (tab_int)
INTEGER, DIMENSION(:) :: tab_int
END FUNCTION moy_int
FUNCTION moy_real (tab_real)
REAL, DIMENSION(:) :: tab_real
END FUNCTION moy_real
FUNCTION moy_comp (tab_comp)
COMPLEX, DIMENSION(:) :: tab_comp
END FUNCTION moy_comp
END INTERFACE moyenne
Dans cet exemple, la fonction moyenne accepte en argument un tableau de rang1 soit dentiers,
soit de rels, soit de complexes. La moyenne sera effectivement calcule en faisant appel la fonction
correspondant au type de largument donn.
VII.D
SURCHARGE ET CRATION DOPRATEURS
La notion de surcharge des oprateurs prdfinis par le langage est propre aux langages orients
objets. On entend par surcharge dun oprateur: un largissement de son champ dapplication. Il faut,
66
bien entendu, dfinir les nouvelles oprations entre les objets. La surcharge d'un oprateur impose de
respecter sa nature et les rgles de priorit prcdemment dfinie dans le langage.
Habituellement, un oprateur retourne une valeur, construite en fonction des expressions donnes.
On emploie alors des procdures de type FUNCTION pour surcharger les oprateurs. Toutefois, une
exception est faite pour loprateur daffectation = qui ne retourne aucune valeur, il faut donc
utiliser une procdure de type SUBROUTINE, pour surcharger cet oprateur.
On dfinit la surcharge dun oprateur grce un bloc INTERFACE.
Remarque: en gnral, la surcharge est dfinie dans un module.
Remarque: Certains oprateurs ont dj fait l'objet d'une surcharge au sein du langage.
VII.D.1 Interface OPERATOR

Pour surcharger un oprateur (autre que l'oprateur d'affectation), on utilisera un bloc d'interface,
en lui ajoutant linstruction OPERATOR. Le bloc interface a la mme syntaxe et la mme fonction que
dans le cas des interfaces explicites. Cest le compilateur qui choisit quelle procdure sera effectivement
utilise lors de tel ou tel appel.
On indique loprateur que lon veut surcharger, entre parenthses, la suite du mot cl
OPERATOR:
si, cest un oprateur existant, on utilise directement son signe;
si, on cre un nouvel oprateur, on utilise un identifiant, plac entre les caractres ..
Syntaxe gnrale:
interface operator (*)

(ou autre signe)
function nom_fun (list_arg)
bloc dclaratif avec intent (in)
end function nom_fun
end interface
ou:
interface operator (.nom_op.)

function nom_fun (list_arg)
bloc dclaratif avec intent (in)
end function nom_fun
end interface
Remarque: Les arguments de la fonction, associe un oprateur pour sa sur-dfinition, doivent
avoir lattribut intent(in).
67
Exemple VII.9
MODULE TYPMAT
TYPE MAT_INT
INTEGER :: lin, row
INTEGER :: DIMENSION(:,:), POINTER :: ptr_mat
EN TYPE MATRICE
END MODULE TYPMAT
INTERFACE OPERATOR (*)
FUNCTION MULT(a, b)
USE TYPMAT
TYPE (mat_int), INTENT (IN) :: a, b
TYPE (mat_int) :: mult
END FUNCTION MULT
END INTERFACE
TYPE (mat_int) FUNCTION MULT(a, b)
USE TYPMAT
TYPE (mat_int) , INTENT (IN) :: a, b
INTEGER, TARGET, PRIVATE :: i, j
INTEGER :: ok
i = a%lin ; j = b%row
mult%lin = i ; mult%row = j
ALLOCATE(mult%ptr_mat(i,j), stat=ok)
IF (ok > 0) THEN
PRINT*, Erreur dallocation de mult
STOP 120
END IF
mult%ptr_mat = MATMUL(a%ptr_mat, b%ptr_mat)
END FUNCTION MULT
VII.D.2 Interface ASSIGNMENT

Comme nous lavons mentionn prcdemment, loprateur daffectation se comporte
diffremment des autres oprateurs, car il ne retourne pas une nouvelle valeur. Donc pour surcharger cet
oprateur, on utilise linstruction ASSIGNMENT(=). La syntaxe est identique au bloc INTERFACE
68
OPERATOR, se reporter donc lexemple prcdent. Par contre, on utilisera une procdure de type
subroutine pour sur dfinir laffectation.
Syntaxe gnrale:
interface assignment (=)

subroutine nom_fun (list_arg)
bloc dclaratif avec intent(out)
puis intent (in)
end subroutine nom_fun
end interface
Remarque: Les arguments de la subroutine, associe loprateur = pour sa sur-dfinition,
doivent avoir respectivement:
lattribut intent(out) ou intent(inout), pour le premier argument, qui est loprande de
gauche;
lattribut intent(in), pour le second argument, qui est loprande de droite.
69
VIII LES ENTRES/ SORTIES

Le langage Fortran dispose d'un ensemble de possibilits en matire d'entre/ sortie (E/S)
particulirement riches.
Les nouvelles caractristiques significatives apportes par la norme Fortran 90 sont:
les E/S sans dplacement (nom-advancing I/O),
les listes nommes (NAMELIST),
quelques nouveaux spcificateurs des instructions OPEN et INQUIRE.
quelques nouveaux descripteurs d'dition et une gnralisation du descripteur d'dition G,
VIII.A INSTRUCTIONS GNRALES

Les instructions gnrales dentre/ sortie sont les instructions de lecture et dcriture: READ,
WRITE et PRINT. On distingue les entres/ sortie accs directes des entres/ sortie squentielles.
Laccs squentiel permet de traiter les enregistrements dans lordre dans lequel ils
apparaissent; ils sont donc reprs par la position du pointeur.
Tandis que laccs direct gre des enregistrements de taille unique dans un ordre quelconque;
ils sont donc reprs par un numro denregistrement (REC).
Syntaxe gnrale accs squentiel:
read ([unit=]unit, [fmt=]format [, iostat] [, err]

[, end] [, advance] [, size] [, eor]) list_var
write ([unit=] unit, [fmt=]format [, iostat] [, err]
[, advance]) list_var
print fmt, list_var
Syntaxe gnrale accs direct:
read ([unit=]unit, [fmt=]format [, rec] [, iostat]

[, err] [, end]) list_var
write ([unit=]unit, [fmt=] format [, rec] [, iostat]
[, err]) list_var
Les paramtres sont les suivants :
unit dsigne lunit dans laquelle on veut lire ou crire;
fmt est lindicateur de format;
rec dsigne le numro de lenregistrement;
iostat indicateur derreurs;
err renvoie ltiquette dinstruction en cas derreurs;
end renvoie ltiquette dinstruction lorsque la fin de fichier est rencontre;
70
advance prcise si le pointeur avance ou pas la fin de lenregistrement;

size permet de rcuprer la longueur denregistrement;
eor renvoie ltiquette dinstruction lorsque la fin denregistrement est rencontre.
VIII.A.1 Description des paramtres de lecture/ criture

a) lunit
Lorsquon veut accder un fichier, on donne au paramtre unit la valeur entire qui repre le
fichier. Le numro didentification du fichier est dfini son ouverture (voir linstruction OPEN ciaprs).
Lorsquon veut accder une variable du type chane de caractres, on affecte au paramtre unit le
nom de la variable.
Exemple VIII.1
INTEGER :: n, k
CHARACTER (LEN=10), PRIVATE :: name = 'graphX.out'
INTEGER, PRIVATE :: iname = 0
DO k = 1, n
iname = iname + 1
WRITE(name(6:6),'(i1)') iname
EN DO
b) le format
Pour crire un format denregistrement, il faut connatre quelques rgles: on prcise le type
denregistrement, le nombre total de caractres, le nombre de chiffres significatifs pour les nombres
dcimaux..., puis on peut affiner le format avec des espaces
Les descripteurs de types:
a: pour une chane de caractres;
l: pour une valeur logique;
i: pour un nombre entier;
f: pour un nombre dcimal;
e: pour un rel en notation scientifique;
Ensuite, on donne le nombre de caractres directement: a3, par exemple.
Lors de lutilisation de formats identiques, les uns la suite des autres, on peut multiplier les
formats directement avec un nombre de fois: 4a3, par exemple, pour crire 4 fois une chane de 3
caractres. Pour des format plus complexes, on se sert de parenthses et on opre une distribution
comme pour la multiplication. Par exemple: 4(a3, i2)
71
On peut sauter des caractres, avec lidentifiant x: 4(a3, 1x, i2). Ainsi, on saute 1 caractre entre la
chane de 3 caractres et lentier 2 chiffres; le tout est rpt 4 fois. En criture, cela revient laisser
un espace.
On peut se positionner dans la mmoire tampon, avec le descripteur t. Pour cela, on indique aussi
lemplacement sur lequel on veut pointer. Par exemple: t20, veut dire se placer sur le 20ime caractre de
la ligne.
Le caractre / indique daller une nouvelle ligne.
On peut aussi appliquer un facteur dchelle, sur les nombres rels, laide de lidentifiant p. Par
exemple, 3p devant les autres descripteurs, multiplie par 103 la mantisse et diminue lexposant de 3.
Ces descripteurs de format sont les plus couramment utiliss, mais la liste des descripteurs nest
pas, ici, exhaustive, ni mme leurs effets. Pour plus de dtails, il faut se rfrer un manuel complet du
langage Fortran.
Exemple VIII.2
FORMAT (val1 = , 1p, f7.4, 1x, val2 = , i3)

FORMAT (Les resultats sont : , 3(e12.4, 2x, f8.3))
FORMAT (t12, 3(e12.4, 2x, f8.3), 3x, i20)
c)
le numro de lenregistrement
Ce paramtre (rec) ne sert que dans les fichiers accs direct et repre le numro de
lenregistrement. Cest donc une valeur entire.
d) lindicateur derreurs
On utilise le paramtre iostat, pour grer les erreurs denregistrement. Ce paramtre peut prendre
plusieurs valeurs, de type entier:
il est nul, lorsquil ny a aucune erreur;
il est ngatif lorsque lerreur est gnre par un fin:
de fichier (end),
ou denregistrement (eor), dans les accs squentiels formats, sans
avancement du pointeur (advance = no);
il est positif dans les autres cas derreurs.
e)
err renvoie ltiquette dinstruction en cas derreurs
Les trois paramtres err, end et eor reoivent chacun une tiquette, qui renvoie linstruction
correspondante, en fonction des besoins. Ainsi, le programmateur peut dcider de la suite du
programme, lorsque des erreurs surgissent dans la lecture ou lcriture denregistrement, lorsquune fin
de fichier, ou bien une fin denregistrement, sont respectivement rencontres.
72
Exemple VIII.3: tiquettes dinstruction
CHARACTER (LEN=4) :: nom

DO
READ (15, i4, err=105, end=106) nom
END DO
105 PRINT*,erreur a la lecture ; STOP 222

106 PRINT*,on a fini !
Note : Le paramtre iostat permet aussi dorienter le programme si une erreur apparat, ou si une
fin de fichier est dtecte. Lintrt est de permettre une programmation plus structure que celle de
lexemple prcdent.
Exemple VIII.4
CHARACTER (LEN=4) :: nom

INTEGER :: dem
DO
READ (15, i4, iostat=dem) nom
IF (dem > 0) THEN

PRINT*,erreur a la lecture ; STOP 222
ELSE
PRINT*,on a fini ! ; EXIT
END IF
END DO
f)
avancement ou non du pointeur
Par dfaut, lors de lexcution dune instruction dentre/ sortie, le pointeur dun fichier passe
lenregistrement suivant. Toutefois, on peut prciser que le pointeur reste sur le dernier enregistrement,
avec le paramtre advance.
advance = no spcifie que le pointeur reste sur place;
advance = yes spcifie que le pointeur avance lenregistrement suivant (cest le dfaut).
Dans le cas denregistrement statique (advance = no), le format doit toujours tre fix.
73
g) longueur denregistrement
Dans le cas o une fin denregistrement est dtecte, le paramtre size permet de rcuprer la
longueur de lenregistrement. Ce paramtre ne sapplique qu une instruction de lecture statique
(advance = no), et donc formates.
READ (12, fmt=405, advance = no, size = l, eor=106) var
106 PRINT*, longueur , l
VIII.B OUVERTURE DE FICHIERS

Linstruction OPEN permet douvrir un fichier, la syntaxe gnrale est la suivante:
open (unit, file, status, action, access, iostat, err,

position, form, recl, blank, pad, delim)
unit: numro didentification de lunit logique que lon manipule;

file: nom du fichier que lon ouvre;
status:statut du fichier (nouveau, ancien);
action: prcise ce quon veut faire de ce fichier (lecture, criture);
access: prcise laccs direct ou squentiel un fichier;
iostat: sert mentionner sil y a des erreurs lexcution;
err: sert donner une instruction en cas derreurs;
position: indique la position du pointeur du fichier;
form: prcise si un fichier est format ou non;
recl: prcise la longueur dun enregistrement;
blank: prcise la gestion des espaces lors de la lecture;
pad: sert pour complter ou non avec des blancs les enregistrements;
delim: sert dlimiter des chanes de caractres.
VIII.B.1 Description des paramtres douverture

a) lunit logique
On repre un fichier par un numro, en affectant une valeur au paramtre unit. Tant que le fichier
reste ouvert, il est identifi par ce numro dans les instructions dentre/ sortie du reste programme.
Exemple VIII.5
OPEN (unit=20)
READ(20, fmt=12) var
b) nom du fichier
On affecte, au paramtre file, une chane de caractres qui est le nom du fichier ouvrir.
74
Exemple VIII.6
OPEN (unit=20, file=fich_res)

c)
status
Ce paramtre peut recevoir une de ces cinq affectations: new, old, unknown, replace, scratch.
new: si le fichier doit tre cr.
old: si le fichier doit dj exister.
unknown: statut inconnu qui dpend de lenvironnement.
replace: si le fichier existe dj lors de louverture, il sera dtruit et dans tous les cas un
nouveau fichier sera cr.
scratch: indique qu'un fichier anonyme sera cr et connect l'unit spcifie via le
paramtre unit. La dure de vie de ce fichier sera soit le temps d'excution du programme, soit
le temps s'coulant jusqu' la fermeture de cette unit.
d) vocation du fichier
Le paramtre action peut recevoir les attributs read, write, readwrite.
read: toute tentative d'criture est interdite.
write: toute tentative de lecture est interdite.
readwrite: les oprations de lecture et d'criture sont autorises.
e)
accs direct ou squentiel
Pour prciser le type daccs un fichier, on affecte la paramtre access des attributs sequentiel ou
direct. Laccs squentiel tant laccs par dfaut.
Exemple VIII.7
OPEN (unit=20, file=fich_res, action=write,&

acces=direct)
f)
dtection derreurs
On se sert du paramtre iostat pour dtecter les erreurs lors de louverture:

iostat = 0: il ny a pas derreurs:
iostat > 0: des erreurs sont survenues.
g) instruction en cas derreurs

On affecte une tiquette au paramtre err. En cas derreur dtectes, le programme excute les
instructions contenues partir de ltiquette. (Voir Exemple VIII.3: tiquettes dinstruction.)
h) position du pointeur du fichier

Le paramtre position peut recevoir les attributs rewind, append, asis.
rewind: le pointeur du fichier sera positionn au dbut du fichier.
75
asis: permet de conserver la position du pointeur de fichier. Il est utile lorsqu'on veut modifier
certaines caractristiques du fichier, tout en restant positionn au mme endroit.
append: le pointeur du fichier sera positionn la fin du fichier.
i)
type format ou non
On spcifie le type des enregistrements, contenus dans un fichier, laide du paramtre form, qui
reoit ainsi les attributs formatted ou unformatted. Par dfaut, les enregistrements sont formats.
j)
longueur dun enregistrement
La paramtre recl spcifie la longueur dun enregistrement pour laccs direct, sinon prcise la
longueur maximale dun enregistrement pour laccs squentiel.
k) blank
Ce paramtre ne sutilise que dans le cas denregistrements formats. Il peut prendre les attributs
null, ou zero.
null: on ne tient pas compte des espaces, comme si il nexistaient pas.
zero: on remplace les espaces par des 0.
l)
pad
Ce paramtre reoit les attributs yes, ou no.

yes: un enregistrement lu avec format est complt par des blancs, si ncessaire.
no: pas de complment avec des blancs.
m) dlimitation des chanes de caractres

Le paramtre delim peut recevoir les attributs apostrophe, quote, none.
apostrophe: indique que l'apostrophe sera utilis pour dlimiter les chanes de caractres lors
d'une criture de type namelist.
quote: indique que l'apostrophe sera utilise pour dlimiter les chanes de caractres lors d'une
criture de type namelist.
none: indique qu'aucun dlimiteur ne sera utilis (valeur par dfaut)
VIII.C LINSTRUCTION INQUIRE

Cest un instruction dinterrogation sur les paramtres dun fichiers. Elle renvoie donc une valeur
logique .TRUE. ou .FALSE. Elle possde des paramtres trs proches de ceux de linstruction
open: position, delim, action, pad ont la mme signification et les mmes valeurs que pour l'instruction
open.
76
Syntaxe gnrale:
inquire (unit, file, iostat, err,

opened, exist, number, named, name,
read, write, readwrite, action, access, direct,
position, form, recl, nextrec, blank, pad, delim)
a) read, write, readwrite
Ces paramtres reoivent chacun les attributs yes, no ou unknown.; ils indiquent respectivement
si la lecture, lcriture et la lecture et lcriture, dans un fichier, sont autorises ou non, ou
indtermines.
VIII.C.2 Par liste de sortie

Une variante de l'instruction INQUIRE permet de se renseigner sur la longueur d'une liste de sortie
lorsque l'criture d'enregistrements non formats est souhaite. Cette variante est connue sous le nom
"INQUIRE par liste de sortie", elle a la syntaxe suivante:
inquire (iolength = longueur) out_list

o longueur est une variable scalaire de type entier par dfaut, utilise pour dterminer la longueur de la
liste de sortie non formate out_list.
Note: cette longueur peut tre utilise pour dterminer la valeur fournir au spcificateur recl lors
d'une prochaine instruction open.
Exemple VIII.8
INTEGER
:: longueur
...
INQUIRE (IOLENGTH=longueur) nom, adresse, tel
...
OPEN (1, FILE='repertoire', RECL=longueur, &
FORM='unformatted')
...
WRITE(1) nom, adresse, tel
VIII.D LINSTRUCTION NAMELIST

L'instruction namelist permet de lier un ensemble de variables dans un seul groupe, afin de
faciliter les oprations d'entre/sortie.
77
VIII.D.1 Dclaration
La dclaration d'un tel groupe se fait par une instruction de spcification namelist avant toute
instruction excutable, dont la forme est:
namelist /nom_namelist/ liste_var

Remarques:
Il est possible de complter l'numration de la liste dans la mme unit de porte.
Si une variable a l'attribut PUBLIC, aucune variable dans la liste nomme ne peut avoir
l'attribut PRIVATE.
Les champs doivent tre des variables dfinies la compilation, donc pas de paramtres de
tableaux ou de chanes, dobjets automatiques ou pointers
VIII.D.2 Usage
Dans une instruction READ ou WRITE, la liste nomme sera dsigne par le spcificateur nml.
Exemple VIII.9
INTEGER, DIMENSION(5) :: age = (/6, 7, 8, 9, 10/)

CHARACTER (LEN=3) :: classe(5)=(/'cp','ce1','ce2',
'cm1','cm2'/)
CHARACTER (LEN=15) :: maitre(5) =
NAMELIST /ecole/ age, classe, maitre
...
READ(*, nml=ecole)
! lit des donnes sous la forme suivante:
&ECOLE maitre(4) = Mme Grosso /
&ECOLE maitre(2) = M. Chaduiron /
...
WRITE(*, nml= ecole)
! gnre les lignes suivantes :
&ECOLE AGE = 6, 7, 8, 9, 10, CLASSE = cpce1ce2cm1cm2
MAITRE = M. Chaduiron Mme Grosso
/
78
79
IX
IX.A
ANNEXE
QUELQUES FONCTIONS INTRINSQUES
IX.A.1
Manipulation de bits
Les variables i, j, n, m, utilises sont toutes des valeurs entires. On rappelle que les bits dun
nombre sont numrots de gauche droite et comment avec le bit 0.
iand (i, j)
ieor (i, j)
ior (i, j)
Ces trois fonctions renvoient respectivement un entier du mme nombre de bits que i, form par le
rsultat des trois oprations logiques: ET, OU exclusif, OU inclusif, effectues bit bit entre les entiers
i et j.
ishft (i, shift [, size])

ishftc (i, shift [, size])
Ces fonctions procdent un dcalage vers la gauche, ou vers la droite, du nombre de bits indiqu
par shift. Lorsque shift est positif, on dcale vers la gauche, lorsque shift est ngatif, on dcale vers la
droite. La fonction ishft remplie les bits manquants par des 0, tandis que la fonction ishftc opre une
permutation circulaire. Elles renvoient toutes les deux un entier du mme nombre de bits que lentier i.
Exemple IX.1
ishft(120,2)
ishftc(134678, 8)
donne 480
donne 34477568
not (i)
Cette fonction fait le complment 1 (ou complment logique) des bits de lentier i; elle retourne
un entier du mme nombre de bits que i.
btest (i, n)
Cette fonction renvoie .TRUE. si le nime bit du nombre entier i est 1, sinon .FALSE. si
il est 0.
80
ibset (i, n)
ibclr (i, n)
Ces deux fonctions retournent un entier identique i, avec respectivement le nime bit 1 et le
nime bit 0.
ibits (i, n, m)
Cette fonction extrait m bits de lentier i, partir du nime bit; puis les dcale vers la droite pour
former un entier du mme type que i (les autres bits de gauche sont mis 0).
mvbits (i, n, m, j, nj)

mvbits est un sous-programme, dons on lappelle avec un call), il est construit sur le mme
principe que la fonction ibits. Il extrait m bits de lentier i, partir du nime bit; puis les place la
njime position de lentier j.
IX.A.2
Prcision et codage numrique
digit(x)
Cette fonction admet un argument x entier ou rel et renvoie un entier gal au nombre de chiffres
significatifs de x:
le nombre de chiffres binaires de la mantisse si x est rel

le nombre de chiffres binaires de stockage (hors bit de signe) si x est un entier.
epsilon (x)
Cette fonction renvoie un rel avec mme paramtre de sous-type que x qui est presque
ngligeable compar 1.
huge (x)
Cette fonction admet un paramtre x entier ou rel et renvoie la plus grande valeur reprsentable
dans le sous-type de x (limite d'overflow).
tiny(x)
Cette fonction admet un paramtre x rel et renvoie la plus petite valeur positive non nulle
reprsentable dans le sous-type de x (limite d'underflow).
maxexponent (x)
Cette fonction admet un paramtre x rel et renvoie l'entier reprsentant le plus grand exposant
possible dans le sous-type de x.
81
minexponent (x)
Cette fonction admet un paramtre x rel et renvoie l'entier reprsentant le plus petit exposant
possible dans le sous-type de x.
exponent (x)
Cette fonction renvoie un entier gal l'exposant de la reprsentation numrique de x (0 si x est
gal 0)
fraction (x)
Cette fonction renvoie un rel qui est gal la mantisse de la reprsentation numrique de x.
nearest(x, s)
Cette fonction renvoie un rel ayant le mme paramtre de sous-type que x, gal au nombre
exactement reprsentable en machine le plus proche de x dans la direction indique par l'argument s.
spacing (x)
Cette fonction renvoie un rel ayant le mme paramtre de sous-type que x, gal l'espacement
absolu des nombres de mme paramtre de sous-type que x dans le voisinage de x.
range (x) et precision (x)

Ces fonctions sont dcrites au chapitre II.C.4c) range et precision.
IX.A.3
Fonctions numriques lmentaires
a) Avec conversion
ceiling (a)
Cette fonction renvoie le plus petit entier du type par dfaut qui est suprieur ou gal a.
floor (a)
Cette fonction renvoie le plus grand entier du type par dfaut qui est infrieur ou gal a.
b) Sans conversion
modulo (a,p)
Cette fonction renvoie a modulo p pour a et p soit tous les deux rels soit tous les deux entiers.
82
IX.A.4
Fonctions lmentaires de type caractre
a) Conversion entier-caractre
achar (i)
Cette fonction renvoie le caractre dont le code ASCII est spcifi par l'argument i.
iachar (c)
Cette fonction renvoie le code ASCII correspondant au caractre c.
ichar (c)
Cette fonction renvoie un entier qui reprsente le numro du caractre c dans la table laquelle
appartient c (ASCII/EBCDIC)
b) Manipulation de chane de caractres

adjustl (string)
Cette fonction cale gauche la chane de caractre STRING.
adjustr (string)
Cette fonction cale droite la chane de caractre STRING.
len_trim
Cette fonction renvoie un entier qui reprsente la longueur de chane de caractre STRING (sans
compter les caractres blancs la fin).
scan (string, set [,back])

Cette fonction renvoie un entier qui reprsente le numro du premier caractre de string o
apparat l'un des caractres de set ou 0 sinon. back est optionnel et permet de trouver la dernire
occurrence.
verify (string, set [,back]):

Cette fonction renvoie un entier qui reprsente le numro du premier caractre de string ne
figurant pas dans set ou 0 sinon. back est optionnel, s'il est gal .TRUE., la recherche se fait depuis
la fin de string.
83
c) Fonctions de comparaison lexicale

lge (stringa, stringb)
lle (stringa, stringb)
Ces fonctions renvoient la valeur .TRUE., respectivement si stringa est aprs ou avant stringb
(ou au mme niveau) dans la table ASCII, sinon .FALSE..
lgt (stringa, stringb)

llt (stringa, stringb)
Ces fonctions renvoient la valeur .TRUE., respectivement si stringa est strictement aprs ou
avant stringb dans la table ASCII, sinon .FALSE..
Remarque: en cas d'ingalit de longueur, la chane la plus courte sera complte blanc sur sa
droite.
repeat (string, n)
Cette fonction permet la formation d'une chane de caractres par concatnation de n fois la chane
string.
trim(string)
Cette fonction renvoie la chane de caractres string sans les blancs ventuels situs sa fin.
IX.B
FONCTIONS DE GNRATION DE NOMBRES ALATOIRES

random_number (harvest)
Ce sous-programme gnre dans harvest un nombre (ou des nombres) pseudo alatoire, dans
l'intervalle [0,1[; harvest doit tre de type rel et peut tre un tableau.
random_seed ([size] [, put] [, get])

Ce sous-programme interroge ou modifie le gnrateur de nombres alatoires. Il nadmet quun
seul des trois arguments la fois.
size: type entier dattribut OUT; le sous-programme retourne alors la taille du tableau
dentiers utiliss comme germe pour la gnration des nombres alatoires.
put: type entier dattribut IN; le sous-programme utilise alors ce tableau dentiers et de rang 1
comme germe pour la gnration des nombres alatoires.
get: type entier dattribut OUT; le sous-programme retourne alors le tableau dentiers et de
rang 1 utilis comme germe pour la gnration des nombres alatoires.
84
IX.C
HORLOGE EN TEMPS REL

date_and_time (date, time, zone, values)
Ce sous-programme retourne dans les variables caractres date et time la date et l'heure en temps
d'horloge murale. L'cart par rapport au temps universel est fourni optionnellement par zone. values est
un vecteur d'entiers rcuprant les informations prcdentes sous forme d'entiers.
system_clock (count, count_rate, count_max)

Ce sous-programme retourne dans des variables entires la valeur du compteur de priode
d'horloge: count, le nombre de priodes par seconde: count_rate et la valeur maximale du compteur de
priode: count_max. On peut, par exemple, valuer le temps CPU consomm par une portion de
programme.
85
IX.D
SITES INTRESSANTS
FORTRAN 90 - procdures prdfinies: http://www.univ-lille1.fr/~eudil/pyrz/home.htm

Le Programmeur : Fortran 90: http://www.stcommunications.ca/~mboisso/Fortran_90
Bibliothque Fortran-90 oriente Objet: http://www.math.u-psud.fr/~laminie/F90_lib
Cours IDRIS Fortran90 / 95: http://www.idris.fr/data/cours/lang/f90
http://consult.cern.ch/cnl/215/node28.html
Fortran 90/ 95 - Le site Francophone: http://www2.cnam.fr/~lignelet/ftn.htmlx
http://cch.loria.fr/documentation/documents/F95
IX.E
BIBLIOGRAPHIE
Manuel Complet du Langage FORTRAN 90 et Langage FORTRAN 95

Calcul intensif et Gnie Logiciel - Auteur: Patrice Lignelet
MASSON, 1996, 314 pages (ISBN 2-225-85229-4)
FORTRAN 90: approche par la pratique

Auteur: Patrice Lignelet
Srie Informatique, dition Menton, 1993, 240 pages (ISBN 2-909615-01-4)
Traitement De Donnes Numriques Avec Fortran 90

Traitement de donnes numriques avec Fortran 90.
1996, 264 pages, Masson, Auteur M. Olagnon
Programmer en Fortran 90 - Guide Complet

Auteur: Claude Delannoy
2000, 413 pages, dition Eyrolles (ISBN 2-212-08982-1)
86

Cours de Fortran

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours de Fortran

Transféré par

Droits d'auteur :

Formats disponibles

Cours de Fortran 90/ 95

Master Recherche (M2)

Anne 2005 2006

Table des Matires

Structure dun programme et syntaxe..............................................................................8

Units de Programme et procdures ......................................................................................... 8

Les procdures externes..........................................................................................................................10

Format et Syntaxe ...................................................................................................................... 15

Les identificateurs et la syntaxe..............................................................................................................15

Chanes de caractres ..............................................................................................................................16

Les types et les dclarations ...................................................................................................... 16

Dclaration de variables scalaires...........................................................................................................17

Dclaration de constantes .......................................................................................................................17

Sous-type: la prcision des nombres .....................................................................................................18

Les fonctions intrinsques lies la prcision .......................................................................................19

Autres types ................................................................................................................................ 20

Les types drivs .....................................................................................................................................21

Vers un langage orient objet .................................................................................................................22

Les fonctions intrinsques......................................................................................................... 23

Structures de contrle ................................................................................................25

Le choix avec IF.......................................................................................................................... 25

Le choix avec SELECT CASE.................................................................................................. 26

Le choix avec WHERE .............................................................................................................. 28

Clause de contrle itrative................................................................................................................29

Clause de contrle WHILE................................................................................................................30

Boucle infinie et altration.................................................................................................................31

Gestion mmoire des tableaux .................................................................................................. 32

Lallocation statique .......................................................................................................................... 32

Lallocation dynamique ..................................................................................................................... 32

La manipulation des tableaux................................................................................................... 35

Les fonctions intrinsques sur les tableaux ............................................................................. 38

Les fonctions dinterrogation ............................................................................................................ 38

Les fonctions de rduction................................................................................................................. 39

Les fonctions de construction et de transformation.......................................................................... 42

Les fonctions propres aux matrices et vecteurs ................................................................................ 44

Dclaration dun pointeur et dune cible........................................................................................... 46

tat dun pointeur ...................................................................................................................... 46

Lallocation dynamique ............................................................................................................. 48

Contrle de visibilit ..................................................................................................52

Les ressources prives et publiques......................................................................................... 52

les types drivs semi-privs ............................................................................................................. 53

Restriction de l'instruction USE ........................................................................................................ 54

Contrle de cohrence ...............................................................................................56

Les arguments de procdure ................................................................................................ 56

Vocation des arguments..................................................................................................................... 56

Prsence optionnelle des arguments.................................................................................................. 58

Passage d'arguments par mots cls.................................................................................................... 59

Interface de procdure .......................................................................................................... 60

Bloc interface dans lunit appelante ................................................................................................ 61

Bloc interface dans un module .......................................................................................................... 62

Rcapitulatif sur linterface explicite ................................................................................................ 65

Interface gnrique ................................................................................................................ 65

Surcharge et cration doprateurs ..................................................................................... 66

Interface OPERATOR ....................................................................................................................... 67

Interface ASSIGNMENT .................................................................................................................. 68

Les entres/ sorties ....................................................................................................70

Instructions gnrales ........................................................................................................... 70

Description des paramtres de lecture/ criture ...............................................................................71

Ouverture de fichiers ............................................................................................................ 74

Description des paramtres douverture............................................................................................74

Par liste de sortie ................................................................................................................................77

Quelques fonctions intrinsques............................................................................................... 80

Prcision et codage numrique ..........................................................................................................81

Fonctions numriques lmentaires ..................................................................................................82