Get documents about "Fortran 2003 (Cour 1)
W
Description
Cours Fortran
Document Sample
Fortran 2003 1
Les apports de Fortran 2003
e
Patrick Corde et Herv´ Delouis
17 mars 2006
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
Fortran 2003 2
Avertissement : vous trouverez ici un certain nombre de notions introduites par la norme
Fortran. Le choix des sujets est arbitraire et non exhaustif. C’est une exploration des
e e e e
principales nouveaut´s. Les exemples propos´s n’ont pu ˆtre pass´s au crible d’un compilateur ;
e
il est donc fort possible que des erreurs ou des interpr´tations approximatives de la norme s’y
e
soient gliss´es...
e
Voici les principaux documents dont nous nous sommes inspir´s :
e e
– Working Draft J3/04-007 - 10 mai 2004 (www.j3-fortran.org). Publi´ par le comit´
e e
international J3 charg´ du d´veloppement de la norme Fortran (585 pages)
– Fortran 95/2003 explained - Michael METCALF, John REID, Malcolm COHEN - 2004 -
OXFORD University Press - ISBN 0-19-852693-8 (416 pages).
u
– The Future of Fortran - John Reid - juillet/aoˆt 2003 - Scientific Programming
(www.computer.org/cise/cs2003/c4059.pdf).
u
– The New Features of Fortran 2000 - John Reid - Fortran Forum V.21 N.2 aoˆt 2002.
– Object Orientation and Fortran 2002 : Part II - Malcolm Cohen : Fortran Forum -
SIGPLAN - V.18 N.1 avril 1999.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 3
e a e
1 – Meilleure int´gration ` l’environnement syst`me . . . . . . . . . . . . . . . 11
e e
2 – Interop´rabilit´ avec C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
e e
2.1 – Entit´s de type intrins`ques . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 – Tableaux C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 – Variables globales C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 – Les pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
e
2.5 – Fonctions C et proc´dures Fortran . . . . . . . . . . . . . . . . . . . . . 22
e
2.5.1 – Exemple de fonction C appel´e depuis Fortran . . . . . . . . . . . . . 24
e e
2.5.2 – Exemple de proc´dure Fortran appel´e depuis C . . . . . . . . . . . . 27
2.5.3 – Interop´rabilit´ entre pointeurs : le type C PTR . . . . . . . . . . . . . 31
e e
e
2.6 – Structures de donn´es C . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
e
3 – Arithm´tique IEEE et traitement des exceptions . . . . . . . . . . . . . . . 55
3.1 – Standard IEEE-754 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
e
3.1.1 – Valeurs sp´ciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 4
3.1.2 – Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.1.3 – Mode d’arrondi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
e e
3.2 – Int´gration standard IEEE : modules intrins`ques . . . . . . . . . . . . . 59
3.3 – Fonctions d’interrogation . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
e
3.4 – Proc´dures de gestion du mode d’arrondi . . . . . . . . . . . . . . . . . . 65
3.5 – Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
e
3.6 – Proc´dures de gestion des interruptions . . . . . . . . . . . . . . . . . . 70
e e
3.7 – Proc´dures de gestion du contexte arithm´tique . . . . . . . . . . . . . . 71
e
3.8 – Exemple compl´mentaire sur les exceptions . . . . . . . . . . . . . . . . 73
e
3.9 – Modules intrins`ques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.9.1 – Module IEEE EXCEPTIONS . . . . . . . . . . . . . . . . . . . . . . . . 75
3.9.2 – Module IEEE ARITHMETIC . . . . . . . . . . . . . . . . . . . . . . . . 77
3.9.3 – Module IEEE FEATURES . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.10 – Documentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 5
e
4 – Nouveaut´s concernant les tableaux dynamiques . . . . . . . . . . . . . . . 85
e
4.1 – Passage en argument de proc´dure . . . . . . . . . . . . . . . . . . . . . 86
e e
4.2 – Composante allouable d’un type d´riv´ . . . . . . . . . . . . . . . . . . . 88
4.3 – Allocation d’un scalaire ALLOCATABLE . . . . . . . . . . . . . . . . . . . . 89
e
4.4 – Allocation/r´allocation via l’affectation . . . . . . . . . . . . . . . . . . . 90
e
4.5 – Sous-programme MOVE ALLOC de r´allocation . . . . . . . . . . . . . . . . 92
e
5 – Nouveaut´s concernant les modules . . . . . . . . . . . . . . . . . . . . . . . 95
5.1 – L’attribut PROTECTED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.2 – L’instruction IMPORT du bloc interface . . . . . . . . . . . . . . . . . . . 96
e
5.3 – USE et renommage d’op´rateurs . . . . . . . . . . . . . . . . . . . . . . . 97
e
6 – Entr´es-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
e
6.1 – Nouveaux param`tres des instructions OPEN/READ/WRITE . . . . . . . . . 99
e
6.2 – Entr´es-sorties asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . 101
e
6.3 – Entr´es-sorties en mode stream . . . . . . . . . . . . . . . . . . . . . . . 103
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 6
e e e
6.4 – Traitement personnalis´ des objets de type d´riv´ . . . . . . . . . . . . . 105
7 – Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
7.1 – Vocation (INTENT) des arguments muets pointeurs . . . . . . . . . . . . 115
7.2 – Association et reprofilage . . . . . . . . . . . . . . . . . . . . . . . . . . 116
e
7.3 – Pointeurs de proc´dures . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
e
7.3.1 – Pointeurs de proc´dure : interface implicite . . . . . . . . . . . . . . . 119
e
7.3.2 – Pointeurs de proc´dure : interface explicite . . . . . . . . . . . . . . . 121
e e e
8 – Nouveaut´s concernant les types d´riv´s . . . . . . . . . . . . . . . . . . . . 125
e
8.1 – Composante pointeur de proc´dure . . . . . . . . . . . . . . . . . . . . . 125
e e e
8.2 – Param`tres d’un type d´riv´ . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.3 – Constructeurs de structures . . . . . . . . . . . . . . . . . . . . . . . . . 129
e
8.4 – Visibilit´ des composantes . . . . . . . . . . . . . . . . . . . . . . . . . . 134
e e
8.5 – Extension d’un type d´riv´ . . . . . . . . . . . . . . . . . . . . . . . . . 136
e
9 – Programmation orient´e objet . . . . . . . . . . . . . . . . . . . . . . . . . 139
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 7
9.1 – Variable polymorphique . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
9.1.1 – Argument muet polymorphique . . . . . . . . . . . . . . . . . . . . . 141
9.1.2 – Variable polymorphique : attribut POINTER, ALLOCATABLE . . . . . . 142
9.2 – Construction SELECT TYPE . . . . . . . . . . . . . . . . . . . . . . . . . . 143
e e
9.3 – Pointeurs g´n´riques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
9.4 – Type effectif d’une variable polymorphique . . . . . . . . . . . . . . . . . 146
e e a
9.5 – Proc´dures attach´es ` un type (type-bound procedures) . . . . . . . . . 148
e e
9.5.1 – Proc´dure attach´e par nom (name binding) . . . . . . . . . . . . . . 149
e e e e
9.5.2 – Proc´dure attach´e par nom g´n´rique (generic binding) . . . . . . . 150
e e e
9.5.3 – Proc´dure attach´e par op´rateur (operator binding) . . . . . . . . . 151
e e e
9.5.4 – Proc´dure attach´e via le mot-cl´ FINAL (final binding) . . . . . . . . 154
e
9.6 – H´ritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
e e
9.6.1 – H´ritage d’une proc´dure type-bound . . . . . . . . . . . . . . . . . . 156
e
9.6.2 – Surcharge d’une proc´dure type-bound . . . . . . . . . . . . . . . . . 158
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 8
e
9.6.3 – Proc´dure type-bound non surchargeable . . . . . . . . . . . . . . . . 160
9.7 – Type abstrait . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
10 – En conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 9
`
Merci d’envoyer toutes remarques concernant ce document a :
Patrick.Corde@idris.fr
a
IDRIS – Bˆt. 506 – BP167 – 91403 ORSAY – FRANCE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
Table des mati`res 10
Notes personnelles
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
1 – Environnement syst`me 11
e a e
1 – Meilleure int´gration ` l’environnement syst`me
e e e
Voici des proc´dures intrins`ques donnant acc`s aux arguments de la ligne de
a
commande ou ` des variables d’environnement.
GET COMMAND(command, length, status)
e
sous-progr. retournant dans command la commande ayant lanc´ le programme.
COMMAND ARGUMENT COUNT()
fonction retournant le nombre d’arguments de la commande.
GET COMMAND ARGUMENT(number, value, length, status)
sous-progr. retournant dans value le numbere argument de la commande
e e a e
(num´rot´s ` partir de z´ro).
GET ENVIRONMENT VARIABLE(name, value, length, status, [trim name])
e e
sous-progr. retournant dans value la valeur de la variable d’environnement sp´cifi´e
e
en entr´e via name.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
1 – Environnement syst`me 12
e e a e
Un nouveau module intrins`que ISO FORTRAN ENV donne acc`s ` des entit´s publiques
concernant l’environnement :
INPUT UNIT, OUTPUT UNIT et ERROR UNIT sont des constantes symboliques de type
e e a e
entier correspondant aux num´ros des unit´s logiques relatifs ` l’entr´e standard,
a
la sortie standard et ` la sortie d’erreur. Ils remplacent avantageusement
e e e
l’ast´risque employ´ traditionnellement au niveau du param`tre UNIT des
instructions READ/WRITE .
IOSTAT END et IOSTAT EOR sont des constantes symboliques de type entier
e e
correspondant aux valeurs n´gatives prises par le param`tre IOSTAT des instructions
e
d’entr´e/sortie en cas de fin de fichier ou fin d’enregistrement. Cela permet
e e e
d’enrichir la portabilit´ d’un code Fortran. Cependant, les cas d’erreurs g´n`rent
e
une valeur positive restant d´pendante du constructeur.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 13
e e
2 – Interop´rabilit´ avec C
e e e e
L’interop´rabilit´ Fortran–C suppose ´videmment que l’on ne manipule que des entit´s
(variables, fonctions, concepts, ...) communes aux deux langages, ce qui impose un
certain nombre de restrictions et de contraintes.
e e
Pour faciliter le travail du programmeur et am´liorer la portabilit´ de son code, la
ee
norme Fortran 2003 fournit un certain nombre de nouveaux ´l´ments syntaxiques
e e e e
n´cessaires pour faciliter la d´finition d’entit´s interop´rables qui seront ainsi connues et
oe a e
contrˆl´es comme telles ` l’´tape de compilation Fortran.
L’acc`s (USE) au module ISO C BINDING permet l’interop´rabilit´ avec C pour
e e e
e
un certain nombre d’entit´s que nous allons passer en revue...
e e
Note : l’interop´rabilit´ Fortran–C est disponible avec le compilateur Fortran
IBM depuis la version 9.1.0.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 14
e e
2.1 – Entit´s de type intrins`ques
e
Via des constantes symboliques d´finissant :
e e e
1. la valeur enti`re du param`tre KIND des types/sous-types autoris´s. Par exemple :
Type/sous-type en Fortran Type correspondant en C
INTEGER(kind=C INT) int
INTEGER(kind=C SHORT) short int
INTEGER(kind=C LONG) long int
REAL(kind=C FLOAT) float
REAL(kind=C DOUBLE) double
CHARACTER(kind=C CHAR) char
etc. ...
Note : pour le type CHARACTER, C ne supportant que les variables de longueur 1
ee e ıne
(g´r´es sous forme de tableaux), on pourra d´clarer une chaˆ sous la forme :
CHARACTER(kind=C_CHAR), dimension(*) :: chaine
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 15
e e
2. des caract`res sp´ciaux :
Nom Signification en C Valeur ASCII ´
Equivalent C
C NULL CHAR null character achar(0) \0
C ALERT alert achar(7) \a
C BACKSPACE backspace achar(8) \b
C HORIZONTAL TAB horizontal tab achar(9) \t
C NEW LINE line feed/new line achar(10) \n
C VERTICAL TAB vertical tab achar(11) \v
C FORM FEED form feed achar(12) \f
C CARRIAGE RETURN carriage return achar(13) \r
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 16
2.2 – Tableaux C
e e
Un tableau Fortran est interop´rable s’il est d’un type interop´rable et de profil
explicite ou de taille implicite.
e e e
De plus pour les tableaux multidimensionn´s, l’ordre des indices doit ˆtre invers´. Ainsi
les tableaux Fortran :
integer(kind=C_INT), dimension(18,3:7,*) :: t1
integer(kind=C_INT), dimension(18,3:7,100) :: t2
e e e
sont interop´rables avec les tableaux ainsi d´clar´s en C :
int t1[][5][18]
int t2[100][5][18]
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 17
2.3 – Variables globales C
e
Une variable externe C peut interop´rer avec un bloc COMMON ou avec une variable
e e
d´clar´e dans un module Fortran. Par exemple :
module variables_C
use, intrinsic :: ISO_C_BINDING
integer( C_INT ), bind(C) :: c_extern
integer( C_LONG ) :: fort_var
BIND( C, NAME=’C_var’ ) :: fort_var
common/COM/ r, s
common/SINGLE/ t
real(kind= C_FLOAT ) :: r, s, t
bind(C) :: /COM/, /SINGLE/
end module variables_C
e e
Ces variables Fortran sont interop´rables avec celles d´finies en C au niveau externe
par :
int c_extern;
long C_var;
struct {float r, s;} com;
float single;
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 18
Remarques
une variable globale Fortran doit avoir ´t´ d´clar´e avec l’attribut BIND(C) pour
ee e e
e
pouvoir ˆtre mise en correspondance avec une variable externe C,
si cet attribut a ´t´ sp´cifi´ sans le param`tre NAME, une r´f´rence externe est
ee e e e ee
e ee e
g´n´r´e enti`rement en minuscules,
si le param`tre NAME a ´t´ pr´cis´, sa valeur correspond au nom de la r´f´rence
e ee e e ee
e ee e
externe g´n´r´e, en respectant les minuscules et/ou majuscules employ´es.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 19
2.4 – Les pointeurs
e
Les pointeurs C, quels qu’ils soient, sont interop´rables avec des pointeurs Fortran
particuliers du type d´riv´ semi-priv´ C PTR dont une composante priv´e contient
e e e e
e
l’adresse cach´e d’une cible.
a a
On retrouve l` l’analogie avec le descripteur du pointeur Fortran qui est sous-jacent `
l’attribut POINTER. Le pointeur en Fortran est un concept abstrait et puissant
e e
n’autorisant pas (fiabilit´ oblige) la manipulation arithm´tique directe de l’adresse qui
e
reste cach´e.
La n´cessit´ de d´finir les pointeurs de type C PTR, souvent appel´s pointeurs C par
e e e e
a
opposition aux pointeurs Fortran, se justifie en partie par le fait que contrairement ` ces
e e e
derniers ils ne peuvent/doivent pas d´signer une zone m´moire non contigu¨. De plus, le
e e
type C PTR est utilisable dans un contexte d’interop´rabilit´ avec tout type de pointeur
e
C (typ´ ou non – void*).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 20
e
Toutes les manipulations relatives aux pointeurs C se font via des op´rateurs ou des
e e
proc´dures (m´thodes), ainsi :
C LOC(X) fonction retournant un scalaire de type C PTR contenant l’adresse de la
cible X (au sens de l’op´ration unaire &X selon la norme C) ; par exemple :
e
use ISO_C_BINDING
real( C_FLOAT ), dimension(10), target :: X
type( C_PTR ) :: buf
buf = C_LOC (X)
` e
A noter que la cible X doit avoir l’attribut TARGET ; elle peut d´signer aussi bien un
e e
scalaire, un tableau statique, un tableau dynamique allou´, ou mˆme un pointeur
ea
associ´ ` un scalaire.
e e
Nous verrons plus loin comment la fonction C LOC facilite l’interop´rabilit´ avec des
pointeurs C.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 21
C F POINTER(CPTR, FPTR [,SHAPE]) : convertit CPTR de type C PTR en un
a e
pointeur Fortran FPTR (SHAPE ` sp´cifier si la cible est un tableau) ;
C ASSOCIATED(C PTR 1[, C CPTR 2]) v´rifie que deux pointeurs C (de type C PTR)
e
a e
sont identiques ou que le premier est ` l’´tat nul.
Notes :
e e
1. si l’interop´rabilit´ concerne un pointeur de fonction (C function pointer type),
e e
on utilisera alors les entit´s ´quivalentes :
e e e
– type d´riv´ semi-priv´ C FUNPTR,
– fonction C FUNLOC(X) retournant l’adresse C d’une proc´dure X dans un scalaire
e
de type C FUNPTR,
– sous-programme C F PROCPOINTER(CFPTR, FPTR) : convertit CFPTR, un pointeur
de proc´dure de type C FUNPTR, en un pointeur Fortran FPTR .
e
e e e
2. ces entit´s permettent l’interop´rabilit´ des tableaux dynamiques : un tableau
e e ea e e ea
Fortran allou´ peut ˆtre pass´ ` C et un tableau allou´ en C peut ˆtre associ´ ` un
pointeur Fortran (cf. exemple en fin de chapitre).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 22
e
2.5 – Fonctions C et proc´dures Fortran
e
Nouveaut´s syntaxiques Fortran :
attribut VALUE pour les arguments muets scalaires. L’argument d’appel
e ee
correspondant n’est plus pass´ par r´f´rence (adresse), mais via une copie
`
temporaire dans le stack. A noter que la copie en retour n’est pas faite, ce qui est
exclusif de intent(OUT/INOUT) !
attribut BIND(C [,NAME=...]) obligatoire ` la d´finition d’une proc´dure Fortran
a e e
e ea e
interop´rable (ou du bloc interface associ´ ` une fonction C dont le nom peut ˆtre
e e e
sp´cifi´ avec le sous-param`tre NAME=).
L’interface de proc´dure Fortran est constitu´e des informations exploitables par
e e
e o e e
Fortran pour d´finir et contrˆler l’interop´rabilit´ avec un prototype de fonction C.
e
Selon les cas, elle est constitu´e de :
e e
Fortran ⇒ C l’appel proc´dural de la fonction C et le bloc interface associ´ ;
e e e
C ⇒ Fortran la partie d´clarative de la proc´dure Fortran appel´e.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 23
e a
Quelques r`gles ` respecter :
interface explicite et attribut BIND(C) obligatoire,
arguments muets tous interop´rables (non optionnels) et en coh´rence avec ceux du
e e
prototype C,
une fonction Fortran doit retourner un scalaire interop´rable et un sous-programme
e
a
doit correspondre ` un prototype C retournant le type void,
un argument du prototype C de type pointeur peut ˆtre associ´ ` un argument
e ea
muet Fortran classique sans l’attribut VALUE (cf. exemple suivant),
un argument du prototype C qui n’est pas de type pointeur doit ˆtre associ´ ` un
e ea
argument muet avec l’attribut VALUE (cf. exemple suivant).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 24
e
2.5.1 – Exemple de fonction C appel´e depuis Fortran
a
Dans cet exemple, Fortran passe ` C deux arguments :
e ee
– un tableau pass´ classiquement par r´f´rence,
e e
– une variable enti`re pass´e par valeur.
e
Tout d’abord, voici la fonction C appel´e et son prototype :
float C_Func( float *buf, int count )
{
float somme = 0. ;
for( int i=0; i<count; i++ ) somme += buf[i] ;
return somme ;
}
e
Ci-apr`s, voici :
le bloc interface associ´ ` la fonction C (dans un module),
ea
le programme Fortran appelant,
un sch´ma r´capitulatif du passage des arguments.
e e
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 25
module FTN_C
use, intrinsic :: ISO_C_BINDING
interface
function C_FUNC (array, N) BIND(C, NAME="C_Func")
import C_INT , C_FLOAT
implicit none
real(kind= C_FLOAT ) :: C_FUNC
real(kind= C_FLOAT ), dimension(*) :: array
integer(kind= C_INT ), VALUE :: N
end function C_FUNC
end interface
end module FTN_C
program p1
use FTN_C
integer(kind= C_INT ), parameter :: n = 18
real( C_FLOAT ), dimension(n) :: tab
real(kind= C_FLOAT ) :: y
call random_number( tab )
y = C_FUNC ( array=tab, N=n )
e
print *, "Val. retourn´e par la fonction : ", y
end program p1
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 26
Exemple : fonction C appelée depuis Fortran
Appelant Fortran Fonction C
+ B.I. + BIND(C) appelée
Arguments d’appel Arguments muets
1
float* buf
2 int count
real(C_FLOAT) :: tab(18)
18
Prototype
integer(C_INT) :: n 18
Stack
Bloc Interface
&tab[0]
integer(C_INT), VALUE :: N
real(C_FLOAT), dimension(*) :: array 18
Appel : y = C_FUNC(array=tab, N=n)
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 27
e e
2.5.2 – Exemple de proc´dure Fortran appel´e depuis C
c
Dans cet exemple, Fortran re¸oit de C trois arguments :
e e
– une variable enti`re pass´e par valeur,
e e ee
– une variable r´elle pass´e par r´f´rence,
a e ee
– un tableau ` taille implicite pass´ par r´f´rence.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 28
Voici le prototype C de la fonction correspondante et le programme C avec une
e
s´quence d’appel de f1 :
void f1( double *b, double d[], long taille_d );
main()
{
double beta = 378.0 ;
double delta[] = { 17., 12.3, 3.14, 2.718, 0.56,
22.67, 25.8, 89., 76.5, 80. } ;
long taille_delta = sizeof delta / sizeof delta[0] ;
f1( &beta, delta, taille_delta ) ;
return 0;
}
Voici le source du sous-programme Fortran F1 :
subroutine F1 (B, D, TAILLE_D) BIND(C, NAME="f1")
use, intrinsic :: ISO_C_BINDING
implicit none
real( C_DOUBLE ), intent(inout) :: B
real( C_DOUBLE ), dimension(*), intent(in) :: D
integer(kind= C_LONG ), VALUE :: TAILLE_D
print *, "B=", B, "D(",TAILLE_D,")=", D(TAILLE_D)
end subroutine F1
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 29
Exemple : procédure Fortran appelée depuis C
Sous−progr. Fortran
Appelant C
appelé BIND(C)
Arguments d’appel Arguments muets
&beta 378.0
real(C_DOUBLE), intent(inout) :: B
beta
double delta[] 0 17.0 real(C_DOUBLE), intent(in) :: D(*)
1 12.3
3 3.14 integer(C_LONG), VALUE :: TAILLE_D
9 80.0
Stack
long taille_delta 10 &beta
&delta[0]
10
Appel : f1(&beta, delta, taille_delta)
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 30
Le prototype de la fonction C associ´e au sous-programme F1 indique qu’aucune
e
e
valeur n’est retourn´e (void).
Le 1er argument muet A de type INTEGER(C LONG) avec l’attribut VALUE correspond
e c e
au param`tre formel a du prototype ; il re¸oit la valeur de alpha copi´e dans le
stack. Attention : l’attribut INTENT (vocation), n’ayant aucun sens dans ce cas, est
interdit !
Le 2e argument muet B de type REAL(C DOUBLE) correspond au param`tre formel b
e
e c
(pointeur typ´ double) du prototype ; il re¸oit l’adresse de beta (&beta).
Le 3e argument muet D de type REAL(C DOUBLE) est un tableau de taille implicite
e c
correspondant au param`tre formel d du prototype ; il re¸oit l’adresse du
1er ´l´ment du tableau delta.
ee
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 31
e e
2.5.3 – Interop´rabilit´ entre pointeurs : le type C PTR
Argument Fortran de type C PTR
Passage par valeur (VALUE) ee
Passage par r´f´rence
• La fonction C r´cup`re le contenu
e e • La fonction C r´cup`re l’adresse
e e
de la composante adresse encap- e
de la composante adresse encapsul´e
Fortran e
sul´e dans l’argument de type C PTR dans l’argument de type C PTR non
⇓ e ea e
n´cessairement d´j` associ´, e e
n´cessairement associ´,
C • intent(OUT/INOUT) interdit, • Bloc interface obligatoire.
• Bloc interface obligatoire. e
=⇒ cf. exemple 2 ci-apr`s
e
=⇒ cf. exemple 1 ci-apr`s
C • C passe a Fortran un pointeur d´j` va-
` ea • C doit passer l’adresse (&p) d’un poin-
⇓ e
loris´, e e
teur qui pourra donc ˆtre associ´ dans
Fortran • intent(OUT/INOUT) interdit. e
la proc´dure Fortran.
e
=⇒ cf. exemple 4 ci-apr`s e
=⇒ cf. exemples 3 et 4 ci-apr`s
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 32
e
Exemple 1 : Fortran =⇒ C (argument C PTR pass´ par valeur)
a
Dans cet exemple, Fortran alloue et valorise un tableau ` deux dimensions. Son adresse
traduite en un pointeur C ` l’aide de la fonction C LOC est transmise par valeur ` une
a a
fonction C.
e e ee e
De plus la fonction C r´cup`re les dimensions du tableau qui lui ont ´t´ pass´es par
valeur.
Notes :
le tableau Fortran d´clar´ avec l’attribut ALLOCATABLE n’est pas interop´rable. Le
e e e
e e
type C PTR employ´ ici permet de contourner ce probl`me,
on donne deux versions de la fonction C, l’une respectant la norme C89, l’autre la
norme C99.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 33
program EXEMPLE_1
use, intrinsic :: ISO_C_BINDING
real(kind= C_FLOAT ), dimension(:,:), allocatable, target :: mat
integer(kind= C_INT ) :: n, m
interface !------------------------------------------!
subroutine c_func ( n, m, v ) bind(C, name="fct")
import C_INT , C_PTR
integer(kind= C_INT ), VALUE :: n, m
type( C_PTR ), VALUE :: v
end subroutine c_func
end interface !--------------------------------------!
read *, n, m ; allocate( mat(n,m) )
call random_number( mat )
call c_func ( n, m, C_LOC (mat) )
print *, "SOMME = ", sum( array=mat, dim=1 )
deallocate( mat )
end program EXEMPLE_1
----------------------------------------------------------------------------------
void fct( int n, int m, float *vec ) void fct( int n, int m, float mat[m][n] )
{ ! {
float **mat; ! for( int i=0; i<m; i++ )
int i, j; ! mat[i][n-1] *= 2.;
mat = malloc( m*sizeof(float *) ); !
for( i=0, j=0; i<m; i++, j+=n ) ! return;
mat[i] = vec+j, mat[i][n-1] *= 2.; ! }
free( mat ); !
} !
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 34
Exemple 1 : Fortran ==> C (argument C_PTR passé par valeur)
Appelant Fortran Fonction C
+ B.I. + BIND(C) appelée
Arguments d’appel Arguments muets
32 20 float *vec
integer(C_INT) :: n, m
n m int n
mat(n,m) int m
Type
C_PTR Prototype
C_LOC(mat)
Stack
Bloc Interface
32 20
integer(C_INT), VALUE :: n, m
type(C_PTR), VALUE :: v
Appel : call c_func(n, m, C_LOC(mat))
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 35
e ee
Exemple 2 : Fortran =⇒ C (argument C PTR pass´ par r´f´rence)
a
Dans cet exemple, Fortran souhaite sous-traiter ` une fonction C l’allocation d’une
ee
matrice n*m qu’il r´f´rencera ensuite via un pointeur Fortran.
` e e
A l’appel de la fonction C, Fortran passe par valeur les deux dimensions n et m d´sir´es
ee e e
et passe par r´f´rence un pointeur interop´rable non encore associ´.
e e e e
La fonction C appel´e alloue une zone m´moire de n*m r´els. Son adresse est stock´e
dans l’objet Fortran pointeurC de type C PTR.
En retour de la fonction C, Fortran convertit l’objet pointeurC en un pointeur Fortran
classique (via la proc´dure C F POINTER) qui devient ainsi associ´ ` la matrice allou´e
e ea e
en C.
a
Ensuite cet objet pointeurC est transmis par valeur ` une autre fonction C afin de
e e
lib´rer la zone allou´e.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 36
program exemple2
use ISO_C_BINDING
integer(kind= C_INT ) :: n, m
type( C_PTR ) :: pointeurC
real(kind= C_FLOAT ), dimension(:,:), pointer :: p_mat
interface
subroutine c_alloc ( ptrC, n, m ) bind(C, name="C_alloc")
import C_PTR , C_INT
type( C_PTR ), intent(out) :: ptrC
integer(kind= C_INT ), VALUE :: n, m
end subroutine c_alloc
subroutine c_free ( ptrC ) bind(C, name="C_free")
import C_PTR
type( C_PTR ), VALUE :: ptrC
end subroutine c_free
end interface
read *, n, m ; call c_alloc ( pointeurC, n, m )
call C_F_POINTER ( CPTR=pointeurC, FPTR=p_mat, shape=(/ n, m /) )
call random_number( p_mat )
print *, "SOMME = ", sum( array=p_mat, dim=1 )
call c_free ( pointeurC )
end program exemple2
----------------------------------------------------------------------
void C_alloc( float **p, int n, int m )
{ *p = malloc( n*m*sizeof(float) ); return ; }
----------------------------------------------------------------------
void C_free( float *p ) { free( p ); return ; }
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 37
Exemple 2 : Fortran ==> C (argument C_PTR passé par référence)
Appelant Fortran Fonction C
+ B.I. + BIND(C) appelée
Arguments d’appel Arguments muets
type(C_PTR) :: pointeurC float **p
int n
int m
R
C_F_POINTE
Prototype
p_mat pointeurC
integer(C_INT) :: n, m 24 12
n m *p=malloc(n*m*sizeof(float))
Stack
Bloc Interface
type(C_PTR), intent(out) :: ptrC 24 12
integer(C_INT), VALUE :: n, m
Appel : call c_alloc(pointeurC, n, m)
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 38
e ee
Exemple 3 : C =⇒ Fortran (argument C PTR pass´ par r´f´rence)
a
Dans cet exemple, C souhaite sous-traiter ` des sous-programmes Fortran la gestion
e e
(allocation, valorisation, traitement, lib´ration) d’un vecteur de 100 r´els.
`
A l’appel du sous-programme for alloc, C passe en argument l’adresse &vec d’un
e
pointeur de r´els.
Dans le sous-programme for alloc, l’argument pointeurC muet correspondant est un
pointeur de type C PTR de vocation INTENT(OUT) sans l’attribut VALUE.
e a
Fortran alloue un tableau de la taille requise dont l’adresse est retourn´e ` C via
ea
l’argument de sortie pointeurC valoris´ ` l’aide de la fonction C LOC.
e a
En retour du sous-programme Fortran, C peut acc`der ` la zone dynamique par
e
l’interm´diaire du pointeur vec.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 39
Voici successivement :
– le programme C appelant avec le prototype des sous-programmes Fortran,
– les sous-programmes Fortran,
e
– un sch´ma du passage des arguments du sous-programme for alloc.
#include <stdio.h>
void F_alloc ( float **, int );
void F_moyenne( float * , int );
void F_free ( void );
int main()
{
const int n = 100;
float *vec;
F_alloc ( &vec, n );
printf( " vec[50] = %f\n", vec[50] );
F_moyenne ( vec, n );
F_free ();
return 0;
}
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 40
module creer_liberer
use ISO_C_BINDING
real(kind= C_FLOAT ), dimension(:), allocatable, target :: vecteur
contains
subroutine for_alloc ( pointeurC, n ) BIND(C, name="F_alloc")
type( C_PTR ), intent(out) :: pointeurC
integer(kind= C_INT ), VALUE :: n
allocate( vecteur(n) )
call random_number( vecteur )
pointeurC = C_LOC ( vecteur )
end subroutine for_alloc
subroutine for_free () BIND(C, name="F_free")
if ( allocated(vecteur) ) deallocate( vecteur )
end subroutine for_free
end module creer_liberer
module calculs
use ISO_C_BINDING
contains
subroutine moyenne ( pointeurC, n ) BIND(C, name="F_moyenne")
type( C_PTR ), VALUE :: pointeurC
integer( C_INT ), VALUE :: n
real(kind= C_FLOAT ), dimension(:), pointer :: p
call C_F_POINTER ( CPTR=pointeurC, FPTR=p, shape=(/ n /) )
print *, "MOYENNE =", sum( p ) / n
end subroutine moyenne
end module calculs
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 41
Exemple 3 : C ==> Fortran (argument C_PTR passé par référence)
Sous−programme Fortran
Appelant C
appelé
Arguments d’appel Arguments muets
const int n=100; 100
integer(C_INT), VALUE :: n
n
type(C_PTR), intent(out) :: pointeurC
&vec
vec
(float *vec;) C_LOC
1 2 3 100
Cible dynamique
vecteur
Stack
C_PTR pointeurC
100
Appel : F_alloc(&vec, n)
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 42
Notes sur l’exemple 3 ci-dessus :
Le tableau dynamique vecteur (allocatable) est d´clar´ comme entit´ globale
e e e
e
dans le module creer liberer car il n’est pas possible de le lib´rer via un pointeur
e e
associ´ pass´ en argument du sous-programme for free.
L’entit´ vecteur pourrait ˆtre d´clar´e avec l’attribut pointer (au lieu de
e e e e
e
allocatable) ; il ne serait alors plus n´cessaire de le globaliser pour pouvoir
e
d´sallouer la cible dynamique anonyme qui lui serait associ´e.e
e
Par contre, sa conversion en pointeur C interop´rable ne pourrait se faire que sous
la forme C LOC(vecteur(1)) car, selon la norme, l’argument de C LOC ne peut ˆtree
ea
un pointeur Fortran associ´ ` un tableau.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 43
ee
Exemple 4 : C =⇒ Fortran (argument C PTR par r´f´rence et par valeur)
e
Dans cet exemple, C sollicite des m´thodes Fortran pour manipuler des objets de type
e e e e
d´riv´ non interop´rables adress´s via un pointeur de type C PTR.
e
1. C d´clare deux pointeurs,
e e
2. C appelle la m´thode INIT pour cr´er et valoriser deux objets de ce type (passage
ee
par r´f´rence),
e
3. C appelle la m´thode ADD pour effectuer un traitement sur ces deux objets (passage
par valeur).
Notes :
– dans la m´thode INIT on utilise la fonction C LOC pour retourner ` la fonction C
e a
e
l’adresse de l’objet allou´.
– dans la m´thode ADD on utilise la proc´dure C F POINTER afin de convertir l’objet de
e e
type C PTR en pointeur Fortran permettant de manipuler l’objet transmis.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 44
module gestion_cellule
use ISO_C_BINDING
type pass
integer n
real, allocatable, dimension(:) :: a |-----------------------------------
... /* Fonction C appelante */
end type pass main()
type(pass), pointer :: p_cel {
contains void *p, *q ;
subroutine init ( data, n ) BIND(C) ...
type( C_PTR ), intent(out) :: data init( &p, 100 ) ;
integer( C_INT ), VALUE :: n init( &q, 200 ) ;
allocate(p_cel) ...
p_cel%n = n add( p, ... ) ;
allocate(p_cel%a(n)) add( q, ... ) ;
data = C_LOC (p_cel)
end subroutine init return 0 ;
subroutine add ( data, ... ) BIND(C) }
type( C_PTR ), VALUE :: data |-----------------------------------
. . .
call C_F_POINTER ( data, p_cel )
. . .
end subroutine add
end module gestion_cellule
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 45
e
2.6 – Structures de donn´es C
Via l’attribut BIND(C).
e
Exemple : un objet de type C struct ainsi d´fini en C :
typedef struct
{
int m, n;
float r;
} C_struct;
e
est interop´rable avec une structure Fortran du type F struc :
use, intrinsic :: ISO_C_BINDING
type, BIND(C) :: F_struct
integer(kind= C_INT ) :: m, n
real(kind= C_FLOAT ) :: r
end type F_struct
e e
Note : les entit´s ALLOCATABLE et les proc´dures sont exclues pour les composantes qui
doivent bien sˆr toutes ˆtre interop´rables ; par contre, les types C PTR et C FUNPTR
u e e
e e
permettent d’y stocker l’adresse C de telles entit´s (cf. exemple ci-apr`s).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 46
a
Exemple Fortran =⇒ C : Fortran passe par valeur ` une fonction C une structure de
e e e a
donn´es (type vecteur ) contenant une composante pointeur interop´rable associ´e ` une
ea e e e e
cible dynamique d´j` allou´e et valoris´e. Via un argument muet d’entr´e d´fini comme
e e a
une structure C ´quivalente, la fonction C peut acc´der ` la cible dynamique.
e e e
Voici tout d’abord un module contenant la d´finition du type d´riv´ Fortran vecteur et
e
le bloc interface de la fonction C appel´e :
module inter
use ISO_C_BINDING
type, BIND(C) :: vecteur
integer(kind= C_INT ) :: n
type( C_PTR ) :: pointeur_C ! Composante dynamique type "pointeur C"
end type vecteur
interface ! <---------- Bloc interface de la fonction C
subroutine moyenne (vec) BIND(c, name="C_moyenne")
import vecteur
type(vecteur), VALUE :: vec
end subroutine moyenne
end interface
end module inter
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 47
Voici le programme Fortran appelant la fonction C ; il lui passe le vecteur v encapsulant
le tableau dynamique tab :
program interoper
use inter
implicit none
type(vecteur) :: v
real( C_FLOAT ), allocatable, dimension(:), target :: tab
v%n = 100
allocate (tab(v%n))
call random_number(tab)
v%pointeur_C = C_LOC (tab)
call moyenne (vec=v) ! <---Appel fonction C
deallocate(tab)
end program interoper
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 48
e e e e
Voici la d´finition de la fonction C moyenne qui r´cup´re en argument le vecteur pass´
e e
par Fortran pour acc´der au tableau allou´ dans le but de calculer la moyenne de ses
ee
´l´ments :
#include <stdio.h>
typedef struct
{
int len ;
float *p ;
} vecteur ;
void C_moyenne(vecteur vec)
{
float moy ;
e e
printf( "Le vecteur vec a %d ´l´ments.\n", vec.len ) ;
moy = 0. ;
for( int i=0; i<vec.len; i++ ) moy += vec.p[i] ;
moy /= vec.len ;
printf( "Moyenne = %f\n", moy ) ;
return ;
}
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 49
Exemple 1 : Fortran ==> C (structure de données en argument avec composante pointeur)
Appelant Fortran Fonction C
+ B.I. + BIND(C) appelée
Arguments d’appel Arguments muets
tab
n 100 1 vecteur vec
Structure
)
v ab 2 Tableau
(t
OC dynamique
C_L
ptr_C Prototype
100
Bloc Interface Stack
type(vecteur), VALUE :: vec
len 100
Appel : call moyenne(vec=v) p &tab[0]
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 50
e e e e
Exemple C =⇒ Fortran : interop´rabilit´ d’une structure de donn´es pass´e par
e a
valeur et contenant une composante pointeur associ´e ` une cible dynamique. Dans cet
e e e
exemple la cible est allou´e en C puis valoris´e dans le sous-programme Fortran appel´.
Voici le sous-programme Fortran valorisation :
module m
use ISO_C_BINDING
implicit none
type, BIND(C) :: vecteur
integer(kind= C_INT ) :: n
type( C_PTR ) :: pointeurC ! Composante dynamique type "pointeur C"
end type vecteur
contains
subroutine valorisation (v) BIND(C, NAME="F_val")
type(vecteur), VALUE :: v
real(kind= C_FLOAT ), dimension(:), pointer :: pointeurF
e
print *, "Taille du vecteur allou´ en C :", v%n
!-- Conversion du "pointeur C" en pointeur Fortran
call C_F_POINTER ( CPTR=v%pointeurC, &
FPTR=pointeurF, &
SHAPE=(/ v%n /) )
call random_number(pointeurF)
end subroutine valorisation
end module m
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 51
e
Programme C et prototype de la fonction Fortran F val appel´e :
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int len ;
float *p ;
} vecteur ;
void F_val(vecteur v) ;
main()
{
float moy ;
vecteur vec ;
moy = 0. ;
vec.p = (float *)calloc(vec.len=1000, sizeof(float)) ;
F_val( vec ) ;
for( int i=0; i<vec.len; i++ ) moy += vec.p[i] ;
moy /= vec.len ; printf( "Moyenne = %f\n", moy ) ;
free(vec.p) ;
return 0 ;
}
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 52
Exemple 2 : C ==> Fortran (structure de données en argument avec composante pointeur)
Appelant C Fonction Fortran appelée
Arguments d’appel Arguments muets
len 1000
vecteur vec type(vecteur), VALUE, intent(in) :: v
p
n 1000
0 1 2 Tableau dynamique 999
Structure
vec.p v pointeurF
pointeurC
C_F_POINTER
Prototype C Stack
1000 len
vecteur vec
Appel : F_val(vec) &vec.p[0] p
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 53
e ee
Reprenons ce mˆme exemple en passant cette fois-ci le vecteur vec par r´f´rence.
a
Voici les modifications ` apporter :
void F_val(vecteur *) ;
main()
{
. . .
F_val( &vec ) ;
. . .
}
module m
. . .
contains
subroutine valorisation(v) BIND(C, NAME="F_val")
type(vecteur), intent(in) :: v
. . .
end module m
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
2 – Interop´rabilit´ 54
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE 55
e
3 – Arithm´tique IEEE et traitement des exceptions
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : standard IEEE-754 56
3.1 – Standard IEEE-754
e e
Le standard IEEE-754 concernant l’arithm´tique r´elle flottante ainsi que le traitement
e e e
des exceptions d´finit un syst`me de repr´sentation des nombres flottants.
e
3.1.1 – Valeurs sp´ciales
e e
Ce syst`me permet la repr´sentation des valeurs sp´ciales suivantes :
e
NaN (Not a Number ) : valeur d’une expression math´matique ind´termin´e comme
e e e
√
0/0, 0 ∗ ∞, ∞/∞, −1,
+INF (+∞), -INF (−∞),
0+ , 0 − ,
d´normalis´es : concernent les tr`s petites valeurs.
e e e
e e e
Dans tout syst`me de repr´sentation, en l’occurrence celui d´fini par le standard IEEE,
e e
l’ensemble des r´els repr´sentables est un ensemble fini.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : standard IEEE-754 57
3.1.2 – Exceptions
e e e e
Dans des cas extrˆmes, une op´ration arithm´tique peut produire comme r´sultat une
e e
des valeurs sp´ciales indiqu´es ci-dessus ou bien une valeur en dehors de l’ensemble des
e e e e e
valeurs repr´sentables. De tels cas g´n`rent des ´v´nements de type exception.
e
Le standard IEEE d´finit 5 classes d’exception :
overflow : valeur calcul´e trop grande,
e
underflow : valeur calcul´e trop petite,
e
division par z´ro,
e
op´ration invalide : valeur calcul´e ´gale ` NaN,
e e e a
op´ration inexacte : valeur calcul´e non repr´sentable exactement (implique un
e e e
arrondi).
e e e
Dans le cas d’un underflow, la valeur calcul´e est soit une valeur d´normalis´e (gradual
underflow ) soit 0 (abrupt underflow ) selon le choix du programmeur.
e e
Lorsqu’une exception se produit, un flag sp´cifique est positionn´.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : standard IEEE-754 58
3.1.3 – Mode d’arrondi
e e e
Lorsque la valeur calcul´e n’est pas repr´sentable, une exception de type op´ration
e ee e
inexacte est g´n´r´e et le calcul se poursuit avec une valeur approch´e (arrondie).
e
Le standard IEEE d´finit 4 modes d’arrondi :
toward nearest (d´faut sur IBM xlf),
e
toward z´ro,
e
toward +INF (+∞),
toward -INF (−∞).
e e
Note : aucune valeur par d´faut n’est pr´vue par la norme !
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 59
e e
3.2 – Int´gration standard IEEE : modules intrins`ques
e e e e
Trois modules intrins`ques permettent l’acc`s aux fonctionnalit´s d´finies par le
standard IEEE :
IEEE ARITHMETIC,
IEEE EXCEPTIONS,
IEEE FEATURES.
e
Ces modules contiennent des d´finitions :
de types,
de constantes symboliques,
de proc´dures.
e
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : fonctions d’interrogation 60
3.3 – Fonctions d’interrogation
e
Ce sont des fonctions d’interrogation sur l’environnement utilis´ afin de savoir s’il est
conforme en tout ou partie au standard IEEE :
IEEE SUPPORT STANDARD(x),
IEEE SUPPORT DATATYPE(x),
IEEE SUPPORT DENORMAL(x),
IEEE SUPPORT INF(x),
IEEE SUPPORT NAN(x),
e
Elles retournent une valeur logique indiquant si l’environnement utilis´ respecte le
e
standard ou un aspect du standard pour le type de l’argument r´el x fourni.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : fonctions d’interrogation 61
ıtre
Il existe des fonctions permettant de connaˆ la classe ou le type de valeur d’un r´el x e
e a
(NaN, ∞, n´gatif, positif, nul, ... ). L’appel ` ces fonctions n’est possible que si la
e a e
fonction IEEE SUPPORT DATATYPE appliqu´e ` ce r´el retourne la valeur vraie.
e e e
Les classes sont d´finies via des constantes symboliques d’un type pr´d´fini
(IEEE CLASS TYPE) dont voici la liste :
IEEE SIGNALING NAN (NaNS),
IEEE QUIET NAN (NaNQ),
IEEE NEGATIVE INF,
IEEE POSITIVE INF,
IEEE NEGATIVE DENORMAL,
IEEE POSITIVE DENORMAL,
IEEE NEGATIVE NORMAL,
IEEE NEGATIVE ZERO,
IEEE POSITIVE NORMAL,
IEEE POSITIVE ZERO,
IEEE OTHER VALUE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : fonctions d’interrogation 62
Ces fonctions sont les suivantes :
IEEE CLASS(x),
IEEE IS NAN(x),
IEEE IS FINITE(x),
IEEE IS NEGATIVE(x),
IEEE IS NORMAL(x).
e e e
De plus la fonction IEEE_VALUE(x, class) g´n`re un r´el d’un type (celui de x) et
e
d’une classe donn´s.
e e e
L’exemple qui suit permet de r´cup´rer la classe d’un r´el x lu dans le fichier fort.1.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : fonctions d’interrogation 63
program class
use IEEE_ARITHMETIC
implicit none
type( IEEE_CLASS_TYPE ) :: class_type
real :: x, y
read( unit=1 )x
if( IEEE_SUPPORT_DATATYPE ( x ) ) then
class_type = IEEE_CLASS ( x )
if ( IEEE_SUPPORT_NAN ( x ) ) then
if ( class_type == IEEE_SIGNALING_NAN ) &
print *,"X is a IEEE_SIGNALING_NAN "
if ( class_type == IEEE_QUIET_NAN ) &
print *,"X is a IEEE_QUIET_NAN "
end if
if ( IEEE_SUPPORT_INF ( x ) ) then
if ( class_type == IEEE_NEGATIVE_INF ) &
print *,"X is a IEEE_NEGATIVE_INF number"
if ( class_type == IEEE_POSITIVE_INF ) &
print *,"X is a IEEE_POSITIVE_INF number"
end if
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : fonctions d’interrogation 64
if ( IEEE_SUPPORT_DENORMAL ( x ) ) then
if ( class_type == IEEE_NEGATIVE_DENORMAL ) &
print *,"X is a IEEE_NEGATIVE_DENORMAL number"
if ( class_type == IEEE_POSITIVE_DENORMAL ) &
print *,"X is a IEEE_POSITIVE_DENORMAL number"
end if
if ( class_type == IEEE_NEGATIVE_NORMAL ) &
print *,"X is a IEEE_NEGATIVE_NORMAL number"
if ( class_type == IEEE_POSITIVE_NORMAL ) &
print *,"X is a IEEE_POSITIVE_NORMAL number"
if ( class_type == IEEE_NEGATIVE_ZERO ) &
print *,"X is a IEEE_NEGATIVE_ZERO number"
if ( class_type == IEEE_POSITIVE_ZERO ) &
print *,"X is a IEEE_POSITIVE_ZERO number"
end if
y = IEEE_VALUE ( x, class_type ); print *,y
end program class
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion mode d’arrondi 65
e
3.4 – Proc´dures de gestion du mode d’arrondi
e ee
Le mode d’arrondi utilis´ lors de calculs est g´r´ par deux sous-programmes (les
e e a
diff´rents modes sont d´finis ` l’aide des constantes symboliques IEEE NEAREST,
e e
IEEE UP, IEEE DOWN, IEEE TO ZERO du type pr´d´fini IEEE ROUND VALUE) :
IEEE GET ROUNDING MODE(round value),
IEEE SET ROUNDING MODE(round value),
use IEEE_ARITHMETIC
implicit none
type( IEEE_ROUND_TYPE ) :: round_value
! Sauvegarde du mode d’arrondi courant.
call IEEE_GET_ROUNDING_MODE ( round_value )
! Positionnement du mode d’arrondi toward +INF
call IEEE_SET_ROUNDING_MODE ( IEEE_UP )
. . .
. . .
e
! Restauration du mode d’arrondi sauvegard´.
call IEEE_SET_ROUNDING_MODE ( round_value )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion des exceptions 66
3.5 – Gestion des exceptions
e e e e
Le programmeur, apr`s avoir d´tect´ la survenance d’une exception, a la possibilit´ de
e
lancer un traitement personnalis´.
`
A chacune des 5 classes d’exception correspondent 2 drapeaux :
l’un indiquant si l’´v´nement relatif ` l’exception s’est r´alis´,
e e a e e
l’autre signalant si ce type d’exception provoque une interruption du programme.
e ee e a
Ces diff´rents drapeaux sont r´f´renc´s ` l’aide de constantes symboliques d’un type
pr´d´fini (IEEE FLAG TYPE) :
e e
IEEE UNDERFLOW,
IEEE OVERFLOW,
IEEE DIVIDE BY ZERO,
IEEE INVALID
IEEE INEXACT
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion des exceptions 67
De plus, deux constantes symboliques de type tableau (IEEE USUAL, IEEE ALL)
ee
permettent de r´f´rencer tout ou partie de ces drapeaux :
IEEE_USUAL = (/ IEEE_OVERFLOW , IEEE_DIVIDE_BY_ZERO , IEEE_INVALID /)
IEEE_ALL = (/ IEEE_USUAL , IEEE_UNDERFLOW , IEEE_INEXACT /)
e
Ces constantes symboliques sont principalement utilis´es comme argument de fonctions
telles que :
IEEE GET FLAG(flag, flag value)
IEEE SET FLAG(flag, flag value)
e
Ces proc´dures retournent dans l’argument flag value un logique signalant l’´tat de
e
l’exception indiqu´e en 1er argument sous forme d’une des constantes symboliques
e
e e
pr´c´dentes.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion des exceptions 68
Exemple d’utilisation
program except
use IEEE_EXCEPTIONS
implicit none
real valeur_calculee
logical flag_value
call IEEE_SET_FLAG ( IEEE_ALL , .false. )
valeur_calculee = 2.453*4.532
e
print *,"valeur_calcul´e : ", valeur_calculee
call IEEE_GET_FLAG ( IEEE_INEXACT , flag_value )
e
if( flag_value ) print *,"Valeur calcul´e inexacte."
end program except
e
Note : lors de l’appel et du retour d’une proc´dure, le contexte de gestion de
e e e
l’arithm´tique IEEE est sauvegard´ puis restaur´. Pour des raisons de performance, ce
e e
processus peut ˆtre inhib´ sur certains environnements via une option du compilateur
(cf. option -qnostrictieeemod de xlf sur IBM).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion des exceptions 69
e
Lorsqu’une exception de type underflow se produit, le r´sultat du calcul est soit 0
e e
(abrupt underflow ) soit un nombre d´normalis´ si le processeur supporte de tels
nombres (gradual underflow ).
e e e
Les deux sous-programmes suivants permettent de g´rer le mode d’underflow d´sir´
(gradual underflow ou abrupt underflow ) :
IEEE GET UNDERFLOW MODE(gradual)
IEEE SET UNDERFLOW MODE(gradual)
use IEEE_ARITHMETIC
implicit none
logical :: save_underflow_mode
! Sauvegarde du mode d’ underflow courant.
call IEEE_GET_UNDERFLOW_MODE ( GRADUAL=save_underflow_mode )
! Positionnement du mode abrupt underflow
CALL IEEE_SET_UNDERFLOW_MODE ( GRADUAL=.false. )
! Calculs dans le mode abrupt underflow ; une valeur
e e
! trop petite est alors remplac´e par z´ro.
! . . .
! Restauration du mode d’ underflow sauvegard´.
e
CALL IEEE_SET_UNDERFLOW_MODE ( GRADUAL=save_underflow_mode )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : gestion des interruptions 70
e
3.6 – Proc´dures de gestion des interruptions
e ee e
Lorsqu’une exception est g´n´r´e, le programme peut s’arrˆter ou bien continuer.
oe
Ce mode de fonctionnement est contrˆl´ par les sous-programmes suivants :
IEEE GET HALTING MODE(flag, halting)
IEEE SET HALTING MODE(flag, halting)
use IEEE_ARITHMETIC
implicit none
real :: x, zero
logical, dimension(5) :: flags
logical :: arret
read *,zero, arret ! zero = 0.
a e
! Mode d’interruption suite ` une division par z´ro.
call IEEE_SET_HALTING_MODE ( IEEE_DIVIDE_BY_ZERO , arret )
x = 1./zero; print *,x
call IEEE_GET_FLAG ( IEEE_ALL , flags )
print *, flags
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : contexte arithm´tique 71
e e
3.7 – Proc´dures de gestion du contexte arithm´tique
e e a e
Deux autres sous-programmes g`rent l’´tat de l’environnement relatif ` l’arithm´tique
flottante (drapeaux d’exceptions et d’interruptions, mode d’arrondi) :
IEEE GET STATUS(status value)
IEEE SET STATUS(status value)
e
L’argument status_value est du type IEEE STATUS TYPE ; il contient en entr´e (SET)
e a e
ou en sortie (GET) l’´tat de tous les drapeaux relatifs ` l’arithm´tique flottante.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : contexte arithm´tique 72
Voici un exemple montrant comment sauvegarder puis restaurer l’ensemble de ces
drapeaux :
use IEEE_EXCEPTIONS
implicit none
type( IEEE_STATUS_TYPE ) status_value
!
! Sauvegarde de tout le contexte flottant IEEE.
call IEEE_GET_STATUS ( status_value )
!
a
! Mettre tous les "drapeaux" de type exception ` faux.
call IEEE_SET_FLAG ( IEEE_ALL , .false. )
!
! e
Calculs avec traitement des exceptions ´ventuelles.
! . . .
e e
! Restauration de tout le contexte flottant IEEE pr´c´dent.
call IEEE_SET_STATUS ( status_value )
! . . .
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : exemple sur les exceptions 73
e
3.8 – Exemple compl´mentaire sur les exceptions
use IEEE_EXCEPTIONS
implicit none
type( IEEE_FLAG_TYPE ), dimension(2), parameter :: &
out_of_range = (/ IEEE_OVERFLOW , IEEE_UNDERFLOW /)
logical, dimension(2) :: flags_range
logical, dimension(5) :: flags_all
call IEEE_SET_HALTING_MODE ( IEEE_ALL , .false. )
. . .
. . .
e e e
call IEEE_GET_FLAG ( out_of_range, flags_range ) !<== Proc´dure ´l´mentaire
if ( any(flags_range) ) then
! Une exception du type "underflow" ou "overflow" s’est produite.
. . .
end if
. . .
. . .
e e e
call IEEE_GET_FLAG ( IEEE_ALL , flags_all ) !<== Proc´dure ´l´mentaire
if ( any(flags_all) ) then
! Une exception quelconque s’est produite.
. . .
end if
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 74
e
3.9 – Modules intrins`ques
e
La disponibilit´ des modules IEEE ARITHMETIC, IEEE EXCEPTIONS et IEEE FEATURES
e e e e
d´pend de l’environnement utilis´, de mˆme que les constantes symboliques d´finies
u
dans le module IEEE FEATURES, dans le cas o` celui-ci est fourni.
Le module IEEE ARITHMETIC se comporte comme s’il contenait une instruction use
IEEE EXCEPTIONS.
Si, dans une unit´ de programme, le module IEEE ARITHMETIC ou IEEE EXCEPTIONS est
e
accessible, les fonctionnalit´s IEEE OVERFLOW et IEEE DIVIDE BY ZERO sont support´es
e e
e e
dans cette unit´ pour tout type de r´els et de complexes. On utilisera la fonction
e
IEEE SUPPORT FLAG afin de savoir si les autres fonctionnalit´s le sont.
e e e e
Ces modules d´finissent 5 types d´riv´s dont les composantes sont priv´es et un
e
ensemble de proc´dures.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 75
3.9.1 – Module IEEE EXCEPTIONS
e
Il d´finit les types :
IEEE FLAG TYPE permettant d’identifier un type d’exception particulier. Les valeurs
possibles sont les constantes symboliques suivantes :
¸ IEEE INVALID,
¸ IEEE OVERFLOW,
¸ IEEE DIVIDE BY ZERO,
¸ IEEE UNDERFLOW,
¸ IEEE INEXACT
IEEE STATUS TYPE pour la sauvegarde de l’environnement flottant.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 76
e
Il d´finit les fonctions d’interrogations suivantes :
IEEE SUPPORT FLAG,
IEEE SUPPORT HALTING,
e ee
Il d´finit les sous-programmes ´l´mentaires suivants :
IEEE GET FLAG,
IEEE GET HALTING MODE,
e ee
Il d´finit les sous-programmes non ´l´mentaires suivants :
IEEE GET STATUS,
IEEE SET FLAG,
IEEE SET HALTING MODE,
IEEE SET STATUS
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 77
3.9.2 – Module IEEE ARITHMETIC
e
Il d´finit les types :
IEEE CLASS TYPE permettant d’identifier la classe d’un r´el. Les valeurs possibles
e
sont les constantes symboliques suivantes :
¸ IEEE SIGNALING NAN,
¸ IEEE QUIET NAN,
¸ IEEE NEGATIVE INF,
¸ IEEE NEGATIVE NORMAL,
¸ IEEE NEGATIVE DENORMAL,
¸ IEEE NEGATIVE ZERO,
¸ IEEE POSITIVE ZERO,
¸ IEEE POSITIVE DENORMAL,
¸ IEEE POSITIVE NORMAL,
¸ IEEE POSITIVE INF,
¸ IEEE OTHER VALUE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 78
IEEE ROUND TYPE permettant d’identifier le mode d’arrondi. Les valeurs possibles
sont les constantes symboliques suivantes :
¸ IEEE NEAREST,
¸ IEEE TO ZERO,
¸ IEEE UP,
¸ IEEE DOWN,
¸ IEEE OTHER
e e
De plus, il surd´finit les op´rateurs == et /= pour deux valeurs d’un de ces types.
e
Il d´finit les fonctions d’interrogation suivantes :
IEEE SUPPORT DATATYPE,
IEEE SUPPORT DENORMAL,
IEEE SUPPORT DIVIDE,
IEEE SUPPORT INF
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 79
e ee
Il d´finit les fonctions ´l´mentaires suivants :
IEEE CLASS,
IEEE COPY SIGN,
IEEE IS FINITE,
IEEE IS NAN,
IEEE IS NORMAL,
IEEE IS NEGATIVE,
IEEE LOGB,
IEEE NEXT AFTER,
IEEE REM,
IEEE RINT,
IEEE SCALEB,
IEEE UNORDERED,
IEEE VALUE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 80
e
Il d´finit la fonction de transformation suivante :
IEEE SELECTED REAL KIND
e ee
Il d´finit les sous-programmes non ´l´mentaires suivants :
IEEE GET ROUNDING MODE,
IEEE GET UNDERFLOW MODE,
IEEE SET ROUNDING MODE,
IEEE SET UNDERFLOW MODE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 81
3.9.3 – Module IEEE FEATURES
e e a
Il d´finit les constantes symboliques (du type IEEE FEATURES TYPE) associ´es ` des
e
fonctionnalit´s IEEE :
IEEE DATATYPE,
IEEE DENORMAL,
IEEE DIVIDE,
IEEE HALTING,
IEEE INEXACT FLAG,
IEEE INF,
IEEE INVALID FLAG,
IEEE NAN,
IEEE ROUNDING,
IEEE SQRT,
IEEE UNDERFLOW FLAG
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
3 – Arithm´tique IEEE : modules intrins`ques 82
e e e
Pour un processeur donn´, une partie de ces fonctionnalit´s peuvent ˆtre naturelles et
seront donc mises en œuvre en l’absence du module IEEE FEATURES. Pour ce processeur,
e
le fait de coder l’instruction use IEEE_FEATURES dans une unit´ de programme aura
e u
pour effet de solliciter d’autres fonctionnalit´s au prix d’un surcoˆt.
e a
Le programmeur peut demander l’acc`s, ` l’aide de la clause ONLY de l’intruction use
e e a e e e
pr´c´dente, ` une fonctionnalit´ particuli`re laquelle peut ˆtre :
naturelle,
g´n´ratrice d’un surcoˆt,
e e u
non disponible, un message d’erreur sera alors ´mis par le compilateur.
e
Exemple :
USE, INTRINSIC :: IEEE_FEATURES, ONLY: IEEE_DIVIDE
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : documentations 83
3.10 – Documentations
http://www.dkuug.dk/jtc1/sc22/open/n3661.pdf ==>
Exceptions and IEEE arithmetic
http://www-1.ibm.com/support/docview.wss?uid=swg27003923&aid=1 ==>
Chapter 16. Floating-point Control and Inquiry Procedures
http://cch.loria.fr/documentation/IEEE754/ACM/goldberg.pdf
e ea
Note : fonctionnalit´s faisant d´j` partie des extensions du compilateur Fortran d’IBM
depuis la version 9.1.0.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
3 – Arithm´tique IEEE : documentations 84
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 85
e
4 – Nouveaut´s concernant les tableaux dynamiques
En Fortran 95, du fait des insuffisances notoires des tableaux dynamiques (attribut
e
ALLOCATABLE), on leur substituait souvent les pointeurs plus puissants, mais pr´sentant
e
des inconv´nients en terme de performance.
e ee
En Fortran 2003, les tableaux allouables sont d´sormais g´r´s par un descripteur
a e
interne analogue ` celui d’un pointeur. Ce descripteur peut ˆtre vu comme un type
e e e
d´riv´ semi-priv´ contenant, entre autres, l’adresse d’une zone dynamique anonyme.
Il est donc normal qu’un tableau dynamique ait maintenant les avantages du pointeur
a e e
vis-`-vis du passage en param`tre de proc´dure et des composantes dynamiques de
e e e e
structures de donn´es ainsi que de nouvelles possibilit´s abord´es ci-apr`s.
e e
On r´servera alors l’usage des pointeurs aux fonctionnalit´s qui leur sont propres :
e e ın´
notion d’alias dynamique d’entit´s ´ventuellement complexes, gestion de listes chaˆ ees,
e e e
pointeurs de proc´dures dans les types d´riv´s, ...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 86
e
4.1 – Passage en argument de proc´dure
e e
En Fortran 95, un tableau allouable ne pouvait ˆtre pass´ en argument d’appel que
e ea e e e e ee
s’il ´tait d´j` allou´. Au sein de la proc´dure appel´e, il ´tait consid´r´ comme un
a
simple tableau ` profil implicite (sans l’attribut ALLOCATABLE).
En Fortran 2003 et en contexte d’interface explicite, un argument muet pouvant avoir
l’attribut ALLOCATABLE, l’argument d’appel correspondant devra aussi avoir cet attribut
e e e e ea e
ainsi que le mˆme rang et le mˆme type/sous-type, sans ˆtre n´cessairement d´j` allou´.
Voici un exemple :
program alloca
real,dimension(:), ALLOCATABLE :: tab
call sp(tab)
CONTAINS
subroutine sp(t)
real,dimension(:), ALLOCATABLE , intent(inout) :: t
ALLOCATE (t(256))
call random_number(t)
end subroutine sp
end program alloca
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 87
Remarques :
Si un argument muet a la vocation INTENT(OUT), l’argument d’appel correspondant
e ea e e e
est automatiquement d´sallou´ ` l’appel de la proc´dure (s’il ´tait allou´).
Comme c’´tait d´j` le cas pour les pointeurs de tableaux en Fortran 95, les bornes
e ea
e e e
inf´rieures/sup´rieures des dimensions d’un tableau allouable pass´ en argument
e e e e u ee e
sont r´cup´rables dans l’unit´ appel´e dans le cas o` celui-ci a ´t´ pr´alablement
e e
allou´ dans l’unit´ appelante.
Quand un objet de type d´riv´ est d´sallou´, toute composante ayant l’attribut
e e e e
e e
ALLOCATABLE est automatiquement d´sallou´e. Si un destructeur (final subroutine –
ea e e
cf. §8.5) est attach´ ` l’objet, il est appliqu´ avant la d´sallocation de cette
composante.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 88
e e
4.2 – Composante allouable d’un type d´riv´
e
L’attribut ALLOCATABLE est autoris´ pour une composante. Voici un exemple :
type obj_mat
integer :: N, M
real,dimension(:,:), ALLOCATABLE :: A
end type obj_mat
. . .
type(obj_mat) :: MAT1
. . .
read *, MAT1%N, MAT1%M
allocate(MAT1%A(MAT1%N, MAT1%M))
. . .
e
C’est bien entendu le descripteur du tableau allouable qui sera stock´ dans la
composante A de MAT1.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 89
4.3 – Allocation d’un scalaire ALLOCATABLE
e a
L’attribut ALLOCATABLE peut dor´navant s’appliquer ` un scalaire. Voici un exemple :
character(len=:), allocatable :: ch
integer :: unit, taille
. . .
read( UNIT=unit ) taille
allocate( character(len=taille) :: ch )
read( UNIT=unit ) ch
. . .
ıne e e a e
Dans cet exemple, la taille de la chaˆ de caract`res ch est d´finie ` l’ex´cution et
fournie ensuite au niveau de l’instruction ALLOCATE en explicitant le type.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 90
e
4.4 – Allocation/r´allocation via l’affectation
e e
Une allocation/r´allocation d’une entit´ var alloc (scalaire ou tableau ayant l’attribut
e
ALLOCATABLE) peut se faire implicitement lors d’une op´ration d’affectation du type :
var alloc = expression
ea e e e e
1. Si var alloc est d´j` allou´e, elle est automatiquement d´sallou´e si des diff´rences
concernant le profil ou la valeur des length type parameters – (cf. §8.2) existent
entre var alloc et expression.
e e e e
2. Si var alloc est ou devient d´sallou´e, alors elle est r´allou´e selon le profil et les
e
param`tres de type de expression. Voici un exemple permettant le traitement d’une
ıne e
chaˆ de caract`res de longueur variable :
character(:), ALLOCATABLE :: NAME !<-- Scalaire character(len=:)
. . . .
NAME = ’chaine_de_car’//’acteres’; . . . .; NAME = ’FIN’
e e
La variable scalaire NAME de type CHARACTER sera allou´e lors de la premi`re affectation
avec une longueur LEN=20. Lors de la 2e affectation, elle sera d´sallou´e puis r´allou´e
e e e e
avec une longueur LEN=3.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 91
` e e ınes
A noter que cette possibilit´ de r´allocation dynamique facilite la gestion des chaˆ
dynamiques ainsi que le respect de la contrainte de conformance lors d’une affectation
de tableaux. Ainsi par exemple :
real, ALLOCATABLE, dimension(:) :: x
. . . .
!--allocate(x(count(masque))) <--- Devient inutile !
. . . .
x = pack(tableau, masque)
e e e e
Le tableau x est automatiquement allou´/r´allou´ avec le bon profil sans se pr´occuper
ee
du nombre d’´l´ments vrais de masque.
e e e
Note : ce processus d’allocation/r´allocation automatique peut ˆtre inhib´ en codant
par exemple :
NAME( : ) = ’chaine_de_car’//’acteres’
x(1 : count(masque)) = pack(tableau, masque)
`
A gauche de l’affectation, la pr´sence du : signifie qu’on fait r´f´rence ` un
e ee a
e e ea e
sous-ensemble d’une entit´ (NAME ou x) qui doit exister et donc ˆtre d´j` allou´e.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 92
e
4.5 – Sous-programme MOVE ALLOC de r´allocation
MOVE ALLOC(FROM, TO) e a e e
r´alloue ` TO l’objet allou´ pass´ via FROM.
e
- FROM entit´ allouable de n’importe quel type/rang. Sa vocation est INTENT(INOUT),
e
- TO entit´ allouable compatible (type et rang) avec FROM. Sa vocation est INTENT(OUT).
e
En retour de ce sous-programme, le tableau allouable TO d´signe le tableau allouable
e e e e e e
FROM ; la zone m´moire pr´alablement d´sign´e par TO est d´sallou´e.
e e
En fait, c’est une m´thode permettant de nettoyer le descripteur de FROM apr`s l’avoir
e
recopi´ dans celui de TO.
e e e
– Si FROM n’est pas allou´ en entr´e, TO devient non allou´ en sortie.
ea ea
– Si TO a l’attribut TARGET, tout pointeur initialement associ´ ` FROM devient associ´ `
TO.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 93
real, ALLOCATABLE, dimension(:) :: grid, tempgrid
. . . .
ALLOCATE(grid(-N:N)) !<-- Allocation initiale de grid
. . . .
ALLOCATE(tempgrid(-2*N:2*N)) !<-- Allocation d’une grille plus grande
!
tempgrid(::2) = grid !<-- Redistribution des valeurs de grid
!
call MOVE_ALLOC(TO=grid, FROM=tempgrid)
TO
1
x
−N +N
grid
4
FROM
x 2
−2N +2N
tempgrid 3
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
4 – Tableaux dynamiques 94
e e
Exemple pr´c´dent en Fortran 95
real, ALLOCATABLE, dimension(:) :: grid, tempgrid
. . . .
ALLOCATE(grid(-N:N)) !<-- Allocation initiale de grid
. . . .
ALLOCATE(tempgrid(-2*N:2*N)) !<-- Allocation d’une grille plus grande
!
tempgrid(::2) = grid !<-- Redistribution des valeurs de grid
!
DEALLOCATE( grid(:) )
ALLOCATE( grid(-2*N:2*N) )
grid(:) = tempgrid(:)
DEALLOCATE( tempgrid(:) )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
5 – Modules 95
e
5 – Nouveaut´s concernant les modules
5.1 – L’attribut PROTECTED
e e e
De mˆme que la vocation INTENT(in) prot`ge les arguments muets d’une proc´dure,
e e e e
l’attribut PROTECTED prot`ge les entit´s d´clar´es avec cet attribut dans un module ;
u
elles sont exportables (use association) mais pas modifiables en dehors du module o`
e
est faite la d´claration.
real(kind=my_prec), PROTECTED , dimension(10,4) :: tab
cet attribut n’est sp´cifiable que dans le module o` est faite la d´claration, pas dans
e u e
ceux qui l’importent (USE) ;
les sous-objets ´ventuels d’un objet prot´g´ re¸oivent l’attribut PROTECTED ;
e e e c
pour un pointeur, c’est l’association et non la cible qui est prot´g´e.
e e
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
5 – Modules 96
5.2 – L’instruction IMPORT du bloc interface
e e e
En Fortran 95, un bloc interface ne pouvait acc´der aux entit´s (d´finition de type
e e e o e
d´riv´ par ex.) de l’unit´ hˆte (module ou unit´ de programme). L’instruction IMPORT
permet l’importation (host association) de ces entit´s dans un bloc interface :
e
module truc
type couleur
character(len=16) :: nom
real, dimension(3) :: compos
end type couleur
interface
function demi_teinte(col_in)
IMPORT :: couleur
type(couleur), intent(in) :: col_in
type(couleur) :: demi_teinte
end function demi_teinte
end interface
contains
e
. . . !---> Partie proc´durale du module
end module truc
e
IMPORT sans liste permet l’importation de toutes les entit´s vues par host association.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
5 – Modules 97
e
5.3 – USE et renommage d’op´rateurs
e e e e
Les op´rateurs non intrins`ques d’un module peuvent ˆtre renomm´s au moment de
leur importation via l’instruction USE. Voici un exemple :
USE my_module OPERATOR(.MY_OPER.) => OPERATOR(.OPER.)
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
5 – Modules 98
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 99
e
6 – Entr´es-sorties
e
6.1 – Nouveaux param`tres des instructions OPEN/READ/WRITE
e ıne e
IOMSG : ce param`tre des instructions READ/WRITE identifie une chaˆ de caract`res
e e
r´cup´rant un message si une erreur, une fin de fichier ou une fin d’enregistrement
a e
intervient ` l’issue de l’entr´e-sortie.
e e e oea
ROUND : lors d’une entr´e-sortie format´e le mode d’arrondi peut ˆtre contrˆl´ ` l’aide
e
du param`tre ROUND de instruction OPEN qui peut prendre comme valeurs : "up",
"down", "zero", "nearest", "compatible" ou "processor defined". Cette valeur
e e a
peut ˆtre chang´e au niveau des instructions READ/WRITE ` l’aide du mˆmee
e e
param`tre ou via les sp´cifications de format ru, rd, rz, rn, rc et rp. La valeur par
e e e
d´faut d´pend du processeur utilis´.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 100
e ee ea
SIGN : ce param`tre a ´t´ ajout´ ` l’instruction OPEN pour la gestion du signe + des
e e
donn´es num´riques en sortie. Il peut prendre les valeurs : "suppress", "plus" ou
e e
"processor defined". Cette valeur peut ˆtre chang´e au moment de l’instruction
a e e a e
WRITE ` l’aide du mˆme param`tre, ou bien ` l’aide des sp´cifications de format ss,
e
sp et s. La valeur par d´faut est "processor defined".
IOSTAT : deux nouvelles fonctions ´l´mentaires is iostat end et is iostat eor
ee
ee e e
permettent de tester la valeur de l’entier r´f´renc´ au niveau du param`tre IOSTAT
de l’instruction READ. Elles retournent la valeur vraie si une fin de fichier ou une fin
ee e e
d’enregistrement a ´t´ d´tect´e.
e e ee
Remarque : les param`tres comme IOSTAT peuvent dor´navant r´f´rencer tout
type d’entier.
INTEGER(kind=2) :: unit, iostat
READ( UNIT=unit, ..., IOSTAT=iostat ) ...
IF( is_iostat_end( iostat ) ) then
. . .
END IF
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 101
e
6.2 – Entr´es-sorties asynchrones
e e
Les entr´es-sorties peuvent ˆtre faites en mode asynchrone, permettant ainsi au
e e
programme de continuer son ex´cution pendant que l’entr´e-sortie est en cours.
Ce mode de fonctionnement n’est possible que pour les fichiers externes ouverts avec le
e e e e
param`tre ASYNCHRONOUS=’yes’. Ce mˆme param`tre sera fourni ´galement au niveau
e e e
de l’instruction READ/WRITE si l’on d´sire lancer une telle entr´e-sortie, sinon, par d´faut
e e
ou en pr´cisant le param`tre ASYNCHRONOUS=’no’, elle sera synchrone quel que soit le
mode d’ouverture effectu´.e
e e a
Une synchronisation peut ˆtre demand´e explicitement ` l’aide de l’instruction
a
WAIT(unit=..., ...). Celle-ci est implicite ` la rencontre d’un INQUIRE ou d’un CLOSE
sur le fichier.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 102
e e e e
Toute entit´ faisant l’objet d’entr´es-sorties asynchrones r´cup`re automatiquement un
nouvel attribut ASYNCHRONOUS dans le but d’avertir le compilateur du risque encouru `a
optimiser des portions de code les manipulant.
e e e
En effet, le r´sultat de cette optimisation pourrait ˆtre un d´placement d’instructions
ee c e
r´f´ren¸ant ces entit´s avant une instruction de synchronisation.
e e
On peut pr´ciser explicitement cet attribut lors de la d´claration :
INTEGER, ASYNCHRONOUS , DIMENSION(10,40) :: TAB
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 103
e
6.3 – Entr´es-sorties en mode stream
e e
Le param`tre ACCESS de l’instruction OPEN admet une troisi`me valeur STREAM
e
permettant d’effectuer des entr´es-sorties en s’affranchissant de la notion
ee e e
d’enregistrement : le fichier est consid´r´ comme ´tant une suite d’octets. L’entr´e-sortie
a a e
est faite soit relativement ` la position courante, soit ` une position donn´e.
e e
Le fichier peut ˆtre format´ ou non.
e e
La position courante est mesur´e en octets en partant de 1. Le param`tre POS de
ıtre.
l’instruction INQUIRE permet de la connaˆ
e e
Le param`tre POS (expression enti`re) des instructions READ/WRITE permet d’indiquer la
a e
position dans le fichier ` partir de laquelle s’effectuera l’entr´e-sortie.
e e e
Cette nouvelle m´thode d’acc`s facilite notamment l’´change de fichiers binaires entre
Fortran et C.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 104
double precision :: d
integer :: rang
. . .
open( UNIT=1, ... , ACCESS="STREAM" , form="unformatted" )
. . .
inquire( UNIT=1, POS=rang ) ! sauvegarde de la position courante.
write( UNIT=1 ) d a
! par rapport ` la position courante.
. . .
a
write( UNIT=1, POS=rang ) d+1 ! par rapport ` la position contenue dans rang.
e
Puisqu’il n’existe pas de notion d’enregistrement logique, il est n´cessaire, pour les
e
fichiers texte, de traiter explicitement le caract`re newline que renvoie la fonction
e
intrins`que new line.
character(len=100) :: chaine
. . .
chaine = "Wolfgang Amadeus Mozart" // &
new_line(’a’) // &
"est un musicien divin."
open( UNIT=1, ... , ACCESS="STREAM" , form="formatted" )
write( UNIT=1, FMT="(a)" ) trim(chaine)
close( UNIT=1 )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 105
e e e
6.4 – Traitement personnalis´ des objets de type d´riv´
a o e
Au-del` du traitement standard, il devient possible de contrˆler les op´rations
e e e e
d’entr´e-sortie portant sur un objet de type d´riv´ (public ou semi-priv´) via une ou
e
plusieurs proc´dures de type SUBROUTINE.
e e e
Il existe 4 cat´gories de proc´dures (lecture/´criture et avec/sans format) qui peuvent
e e c e e e e
ˆtre attach´es de fa¸on g´n´rique (generic bindings) au type d´riv´ de l’objet via des
instructions du type :
GENERIC :: READ(FORMATTED) => lecture_format1, lecture_format2
GENERIC :: READ(UNFORMATTED) => lecture_nonformat1, lecture_nonformat2
GENERIC :: WRITE(FORMATTED) => ecriture_format1, ecriture_format2
GENERIC :: WRITE(UNFORMATTED) => ecriture_nonformat1, ecriture_nonformat2
ee e
ins´r´es au sein de la d´finition du type comme nous le verrons dans les exemples plus
loin.
` e e e a
A droite des fl`ches, on trouve le nom des proc´dures qui seront discrimin´es ` la
e e e
compilation en fonction du type d´riv´ de l’objet trait´ et de la valeur effective des
e e a e
sous-types (param`tre KIND) de ses composantes (param´trables ` la d´claration).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 106
a e e e e e
Une alternative ` l’attachement g´n´rique pr´c´dent est d’ins´rer un bloc interface au
e
niveau de la d´finition du type :
INTERFACE READ(FORMATTED)
MODULE PROCEDURE lecture_format1, lecture_format2
END INTERFACE
e
Concernant les entr´es-sorties avec format, un nouveau descripteur de format DT a ´t´ ee
e a e e e
d´fini. Il s’applique ` un objet de type d´riv´ de la liste d’entr´e-sortie et a pour forme :
ı e
DT [’cha^ne de caract`res’] [(liste d’entiers)]
ıne e e
La chaˆ de caract`res et le tableau d’entiers facultativement indiqu´s avec ce
e e
descripteur sont automatiquement transmis en argument d’entr´e de la proc´dure
e a e
appel´e. Ils sont ` la libre disposition du programmeur pour param´trer le traitement.
e
Note : toutes ces notions sont rep´rables dans la documentation anglaise sous les
e
mots-cl´s dtio-generic-spec et dtv-type-spec.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 107
e
Ce type de proc´dures doit respecter le prototype suivant :
SUBROUTINE lecture_format ( dtv , unit , iotype , v_list , iostat , iomsg )
SUBROUTINE ecrit_nonformat ( dtv , unit , iostat , iomsg )
e e a
dtv : objet de type d´riv´ qui est ` l’origine de l’appel (discriminant en cas
e e e
d’attachement g´n´rique de plusieurs proc´dures),
e e ee e
unit : num´ro de l’unit´ logique sur laquelle a ´t´ connect´ le fichier (0 pour un fichier
interne),
ıne e e
iotype : chaˆ de caract`res indiqu´e au niveau du descripteur de format DT,
e
v list : tableau d’entiers indiqu´ au niveau du descripteur de format DT,
e e e
iostat : refl`te en retour l’´tat de l’entr´e-sortie,
iomsg : contient en retour le texte d’un message d’erreur si iostat est non nul.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 108
e
Voici un exemple avec des enregistrements format´s :
PROGRAM exemple
USE couleur_mod
IMPLICIT NONE
TYPE(couleur) :: c1, c2
REAL :: x, y
INTEGER :: i, ios
CHARACTER(len=132) :: message
NAMELIST/liste/ x, y, c1
...
WRITE( UNIT=1, FMT="(I2, DT ’COMPLET’(6) , 2F6.2 )", &
IOSTAT=ios, IOMSG=message ) i, c1, x, y
PRINT *, ios, message
WRITE( UNIT=1, FMT="(F7.3, DT(7) , DT ’COMPLET’(5) )", &
IOSTAT=ios, IOMSG=message ) x, c1, c2
PRINT *, ios, message
WRITE( UNIT=1, FMT=*, IOSTAT=ios, IOMSG=message ) x, c1, i, y
PRINT *, ios, message
WRITE( UNIT=1, NML=liste )
PRINT *, ios, message
END PROGRAM exemple
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 109
MODULE couleur_mod
TYPE couleur
CHARACTER(len=16) :: nom; REAL, DIMENSION(3) :: compos
CONTAINS
GENERIC :: WRITE(FORMATTED) => ecr_format ! <=== Generic binding.
END TYPE couleur
CONTAINS
SUBROUTINE ecr_format( dtv, unit, iotype, v_list, iostat, iomsg )
TYPE(couleur), INTENT(in) :: dtv
INTEGER, INTENT(in) :: unit
CHARACTER(len=*), INTENT(in) :: iotype
INTEGER, DIMENSION(:), INTENT(in) :: v_list
INTEGER, INTENT(out) :: iostat
CHARACTER(len=*), INTENT(inout) :: iomsg
CHARACTER(len=10), DIMENSION(2) :: fmt
NAMELIST/liste/ dtv%nom, dtv%compos
write( fmt(1), ’(a, i2, a)’ ) "(a,3f", v_list(1), ".2)"
write( fmt(2), ’(a, i2, a)’ ) "(3f", v_list(1), ".2)"
SELECT CASE( iotype )
CASE (’ NAMELIST ’) ; WRITE( UNIT=unit, NML=liste, IOSTAT=iostat, IOMSG=iomsg )
CASE (’ LISTDIRECTED ’); WRITE( UNIT=unit, FMT=* ) dtv%nom, dtv%compos
CASE (’ DTCOMPLET ’) ; WRITE( UNIT=unit, FMT=fmt(1) ) dtv%nom, dtv%compos
DEFAULT ; WRITE( UNIT=unit, FMT=fmt(2) ) dtv%compos
END SELECT
END SUBROUTINE ecr_format
END MODULE couleur_mod
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 110
Exemple de traitement d’un fichier binaire
PROGRAM exemple
USE couleur_mod
IMPLICIT NONE
TYPE(couleur) :: c
REAL :: x, y
INTEGER :: i, ios
CHARACTER(len=132) :: message
...
READ( UNIT=1, IOSTAT=ios, IOMSG=message ) i, c, x, y
DO WHILE ( ios == 0 )
...
READ( UNIT=1, IOSTAT=ios, IOMSG=message ) i, c, x, y
END DO
IF ( ios > 0 ) THEN
PRINT *, message
STOP 4
END IF
END PROGRAM exemple
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 111
MODULE couleur_mod
TYPE couleur
CHARACTER(len=16) :: nom
REAL, DIMENSION(3) :: compos
CONTAINS
GENERIC :: READ(UNFORMATTED) => lec_binaire ! <=== Generic binding.
END TYPE couleur
CONTAINS
SUBROUTINE lec_binaire( dtv, unit, iostat, iomsg )
TYPE(couleur), INTENT(in) :: dtv
INTEGER, INTENT(in) :: unit
INTEGER, INTENT(out) :: iostat
CHARACTER(len=*), INTENT(inout) :: iomsg
READ( UNIT=unit, IOSTAT=iostat, IOMSG=iomsg ) dtv%nom, dtv%compos
END SUBROUTINE lec_binaire
END MODULE couleur_mod
e e e
Remarque : cette nouveaut´ permet de b´n´ficier du concept d’abstraction des
e
donn´es.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 112
e
Exemple de traitement r´cursif
MODULE list_module
TYPE node
integer :: value = 0
type(node), pointer :: next_node => null()
CONTAINS
GENERIC :: WRITE(FORMATTED) => pwf ! <=== Generic binding.
END TYPE node
CONTAINS
RECURSIVE SUBROUTINE pwf( dtv, unit, iotype, v_list, iostat, iomsg )
TYPE(node), INTENT(in) :: dtv
INTEGER, INTENT(in) :: unit
CHARACTER(len=*), INTENT(in) :: iotype
INTEGER, DIMENSION(:), INTENT(in) :: v_list
INTEGER, INTENT(out) :: iostat
CHARACTER(len=*), INTENT(inout) :: iomsg
WRITE( UNIT=unit, FMT=’(I9,/)’, IOSTAT=iostat ) dtv%value
if ( iostat /= 0 ) return
if ( ASSOCIATED( dtv%next_node ) ) &
WRITE( UNIT=unit, FMT=’(dt)’, IOSTAT=iostat ) dtv%next_node
END SUBROUTINE pwf
END MODULE list_module
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 113
c
Ce module pourra s’employer de la fa¸on suivante :
PROGRAM liste
USE liste_module
INTEGER :: unit, iostat
TYPE(node) :: racine
. . .
e ı e
! Cr´ation d’une liste cha^n´e avec racine comme noeud primaire.
. . .
! Impression de la liste.
WRITE( UNIT=unit, FMT=’(dt)’, IOSTAT=iostat ) racine
END PROGRAM liste
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
6 – Entr´es-sorties 114
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 115
7 – Pointeurs
7.1 – Vocation (INTENT) des arguments muets pointeurs
a e
Contrairement ` Fortran 95, il est possible de d´finir la vocation (attribut INTENT) des
e
arguments muets pointeurs au sein d’une proc´dure. C’est l’association qui est
e
concern´e et non la cible.
INTENT(IN) : le pointeur ne pourra ni ˆtre associ´, ni mis ` l’´tat nul, ni allou´ ;
e e a e e
INTENT(OUT) : le pointeur est forc´ ` l’´tat ind´fini ` l’entr´e de la proc´dure ;
ea e e a e e
INTENT(INOUT) : le pointeur peut ` la fois transmettre une association pr´´tablie et
a ee
retourner une nouvelle association.
subroutine sp(p1, p2, ...)
real, dimension(:,:), pointer, INTENT(IN) :: p1
real, dimension(:,:), pointer, INTENT(OUT) :: p2
. . . .
e
Note : fonctionnalit´ faisant partie des extensions du compilateur Fortran d’IBM
depuis la version 95.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 116
7.2 – Association et reprofilage
e e e e
Lors de l’association, il est possible de pr´ciser le profil d´sir´ avec ´ventuellement
modification du rang.
Dans l’exemple suivant, on suppose que le tableau de rang 1 champ vecteurs contient
e e a
les coordonn´es d’une s´rie de vecteurs dans un espace ` 3 dimensions :
Exemple
subroutine sp( champ_vecteurs, n )
real, dimension(:), target :: champ_vecteurs
integer :: n, nb_vecteurs
real, dimension(:,:), pointer :: matrice
nb_vecteurs = size(champ_vecteurs)/3
matrice(1:3,1:nb_vecteurs) => champ_vecteurs
. . .
end subroutine sp
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 117
e
Voici un autre exemple permettant l’extraction de la diagonale d’une matrice suppos´e
e
carr´e.
Exemple
subroutine sp( matrice )
integer :: n
real, dimension(:,:), target :: matrice
real, dimension(:), pointer :: vec
real, dimension(:), pointer :: diagonale
n = size(matrice,1)
vec(1:n*n) => matrice
diagonale => vec(1:n*n:n+1)
end subroutine sp
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 118
e
7.3 – Pointeurs de proc´dures
e e a e
Les pointeurs peuvent ˆtre associ´s ` des cibles de type proc´dure. On parlera alors de
e
pointeurs de proc´dures, assimilables aux pointeurs de fonctions en langage C.
Voici quelques aspects concernant ces pointeurs :
l’interface peut ˆtre implicite ou explicite (cf. ci-apr`s),
e e
une fonction peut retourner un pointeur de proc´dure,
e
au moment de l’association p => proc d’un pointeur de proc´dure p ` l’aide de
e a
e e
l’op´rateur classique =>, le compilateur v´rifie (si l’interface est explicite) la
e e
compatibilit´ des interfaces proc´durales comme pour l’appel classique d’une
e e e
proc´dure. L’op´rande de droite peut ˆtre au choix :
e
– une proc´dure,
e
– un pointeur de proc´dure,
e
– une fonction retournant un pointeur de proc´dure.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 119
e
7.3.1 – Pointeurs de proc´dure : interface implicite
e e
Voici trois possibilit´s de les d´clarer en mode d’interface implicite :
Premi`re possibilit´ (pour une fonction seulement) avec l’attribut POINTER :
e e
REAL, EXTERNAL, POINTER :: p
REAL, EXTERNAL :: f, g
. . .
p => f
print *, p(..., ..., ...)
. . .
p => g
print *, p(..., ..., ...)
Deuxi`me possibilit´ avec les attributs PROCEDURE() et POINTER ; dans l’exemple, p
e e
a e e e e
est un pointeur en mode d’interface implicite, ` l’´tat ind´termin´, pouvant ˆtre
ea
associ´ ` une fonction ou un sous-programme :
PROCEDURE() , POINTER :: p
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 120
Troisi`me possibilit´ (pour une fonction seulement) avec l’attribut PROCEDURE
e e
ee c
r´f´ren¸ant un type pour expliciter partiellement un pointeur de fonction en le
e
d´clarant par exemple sous la forme :
PROCEDURE(TYPE(obj_mat(k=8, dim=256, d=128))) , POINTER :: p
e e a
p ne pourra alors ˆtre associ´ qu’` une fonction retournant un objet de type
e e e e e e
obj mat param´tr´ comme indiqu´ (cf. §8.2 - Param`tres d’un type d´riv´).
e o e
Bien entendu, comme pour les appels de proc´dures, il est plutˆt conseill´ d’utiliser le
o e
mode d’interface explicite afin que le compilateur puisse contrˆler la coh´rence des
e e a
associations de pointeurs de proc´dures... La fiabilit´ est ` ce prix !
e e
Voyons quelles sont les possibilit´s de les d´clarer en mode d’interface explicite.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 121
e
7.3.2 – Pointeurs de proc´dure : interface explicite
Attribut POINTER appliqu´ ` une d´claration de proc´dure effectu´e ` l’aide d’un
ea e e e a
bloc interface :
module m
POINTER :: sp
interface
subroutine sp( a, b )
real, intent(inout) :: a
real, intent(in) :: b
end subroutine sp
end interface
contains
subroutine trace( u, v )
real, intent(inout) :: u
real, intent(in) :: v
. . .
end subroutine trace
end module m
program prog
use m
sp => trace
call sp( ... )
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 122
Attribut PROCEDURE faisant r´f´rence ` une proc´dure mod`le existante. Voici par
ee a e e
e a e e
exemple la d´claration de p initialement ` l’´tat nul avec la mˆme interface que celle
du sous-programme proc (obligatoirement en mode d’interface explicite) :
module m
contains
subroutine proc( a, b )
real, dimension(:), intent(in) :: a
real, dimension(:), intent(out) :: b
. . .
end subroutine proc
end module m
program prog
use m
PROCEDURE(proc) , POINTER :: p => NULL()
. . .
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 123
` e
A d´faut d’une proc´dure pouvant servir de mod`le pour expliciter l’interface, il est
e e
e
aussi possible de d´finir un bloc interface virtuel (abstract interface) comme
celui-ci :
ABSTRACT INTERFACE
SUBROUTINE sub( x, y )
REAL, intent(out) :: x
REAL, intent(in) :: y
END SUBROUTINE sub
END INTERFACE
e e
Ce bloc interface virtuel peut ˆtre utilis´ (via l’attribut PROCEDURE) au moment de
e e e
la d´claration d’un pointeur de proc´dure comme p1 ou mˆme d’une proc´dure e
externe comme proc dans l’exemple ci-dessous :
PROCEDURE(sub) , POINTER :: p1=>NULL()
PROCEDURE(sub) :: proc
REAL :: var
p1 => proc
. . .
CALL p1( x=var, y=3.14 )
PRINT *, ASSOCIATED( p1, proc )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
7 – Pointeurs 124
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 125
e e e
8 – Nouveaut´s concernant les types d´riv´s
e
8.1 – Composante pointeur de proc´dure
e ıtre e e
Un pointeur de proc´dure peut apparaˆ en tant que composante d’un type d´riv´.
e a
L’association puis l’appel de la proc´dure cible s’effectue ` partir d’un objet du type
e e e
d´riv´ au moyen du symbole % comme pour l’acc`s aux composantes habituelles.
e a
Par d´faut, l’objet qui est ` l’origine de l’appel est transmis implicitement comme
a e
premier argument ` la proc´dure cible (passed-object dummy argument). L’attribut
e e e
NOPASS, indiqu´ lors de la d´claration de la composante, empˆche cette transmission
e
implicite : dans ce cas, si on d´sire transmettre l’objet, on le fera explicitement.
e e e
L’attribut PASS peut ˆtre indiqu´ soit pour confirmer le mode par d´faut soit pour
transmettre implicitement l’objet vers un autre argument que le premier.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 126
module m
TYPE mytype
private
real :: x
integer :: i
PROCEDURE(proc) , public, POINTER, PASS :: p
END TYPE mytype
abstract interface
subroutine proc( this, r, i )
type(mytype), intent(inout) :: this
real, intent(in) :: r
integer, intent(in) :: i
end subroutine proc
end interface
end module m
program prog
use m
TYPE(mytype) :: a
a%p => p1
call a%p( 3.14, e a
100 ) ! ´quivalent ` "call p1( a, 3.14, 100 )"
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 127
e e e
8.2 – Param`tres d’un type d´riv´
e e ea e
En Fortran 95, les types intrins`ques ´taient d´j` param´trables ; en particulier le type
e a e e
CHARACTER(LEN= , KIND= ) avait deux param`tres ` valeur enti`re pour sp´cifier le
e
nombre de caract`res et le sous-type.
e e e e
Nuance importante, le premier n’est pas discriminant pour la g´n´ricit´ et pas doit ˆtre
a e e e
connu ` la compilation, tandis que le deuxi`me l’est ; Fortran 2003 g´n´ralise cette
e e e e e e
distinction aux param`tres des types d´riv´s qui pourront ˆtre d´clar´s avec l’attribut
LEN ou KIND.
e e e e
Les param`tres LEN/KIND peuvent ˆtre utilis´s pour d´finir la longueur de chaˆ ınes ou les
e
bornes de tableaux, mais seuls ceux ayant l’attribut KIND (dont la valeur doit ˆtre
a
connue ` la compilation) peuvent intervenir dans une expression d’initialisation ou la
valorisation d’un sous-type (kind-selector ).
e e e
Des valeurs par d´faut peuvent ˆtre d´finies.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 128
e e e
Voici un exemple de type d´riv´ param´trable :
type obj_mat( k , dim , d )
!----------------------------------------
integer, KIND :: k , dim
integer, LEN :: d
!----------------------------------------
integer :: nb_bits= k *8
real(kind= k ),dimension( d , d ) :: tab
real(kind= k ),dimension( dim ) :: vect
end type obj_mat
. . . .
type(obj_mat( k =8, dim =256, d =128)) :: mat
. . . .
e
Les param`tres (ici k, dim et d) sont obligatoirement de type entier avec un attribut
KIND/LEN.
e e e
Seuls ceux ayant l’attribut KIND sont discriminants au niveau de la g´n´ricit´ des
fonctions.
Ceux avec l’attribut LEN font partie des length type parameters par opposition aux kind
type parameters.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 129
8.3 – Constructeurs de structures
e e
Lors de la valorisation d’un type d´riv´ via un constructeur de structure, il est
e e
d´sormais possible d’affecter les composantes par mots cl´s :
type couleur
character*16 :: nom
real,dimension(3) :: compos
end type couleur
. . .
type(couleur) :: c
. . .
c=couleur( nom =’rose_saumon’, compos =[ 0.72, 0.33, 0.05 ] )
. . .
e
Notez aussi la nouvelle notation du constructeur de vecteur encadr´ par des crochets
e
(au lieu des caract`res (/ et /)).
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 130
e e e e
Une proc´dure g´n´rique peut avoir le mˆme nom qu’un constructeur de structure. Les
e e e e
constituants de la famille g´n´rique ont priorit´ sur le constructeur en cas d’ambiguit´.
e e
Cette technique peut ˆtre employ´e afin de surcharger un constructeur, comme le
montre l’exemple suivant :
type mycomplex
real :: rho, theta e
!<=== Coordonn´es polaires
end type mycomplex
interface mycomplex
type(mycomplex) function complex_to_mycomplex(c)
complex, intent(in) :: c e
!<=== Type intrins`que Fortran
end function complex_to_mycomplex
type(mycomplex) function two_reals_to_mycomplex(x, y)
real, intent(in) :: x !
real, intent(in), optional :: y e e
!<=== Coordonn´es cart´siennes
end function two_reals_to_mycomplex
end interface
. . .
type(mycomplex) :: a, b, c
complex :: w
. . .
a = mycomplex( theta=5.6, rho=1.0 ) e
! Appel constructeur intrins`que
b = mycomplex( w ) a
! Appel ` complex_to_mycomplex
c = mycomplex( x=0.0, y=1.0 ) a
! Appel ` two_reals_to_mycomplex
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 131
e ea e
Si une composante d’un type d´riv´ ` une valeur par d´faut, l’argument correspondant
au niveau du constructeur se comporte comme un argument optionnel.
Exemple
type real_liste
real :: valeur
type(real_liste), pointer :: next => null()
end type real_liste
. . .
type(real_liste) :: x = real_liste(3.14)
. . .
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 132
e e
Exemple d’un type param´tr´
type champ_vecteur(n,d,k)
integer, kind :: k = kind(1.0)
integer, len :: d = 2, n
real(kind=k), dimension(d,n) :: champ
end type champ_vecteur
. . .
type(champ_vecteur(k=selected_real_kind(9,99), n=100)) :: c
. . .
c = champ_vecteur(k=selected_real_kind(9,99), n=100)(champ=real(1., kind=c%k))
e e
NOTE : on remarque qu’il est possible d’adresser les composantes d’un type d´riv´ ayant
a e e e
l’attribut LEN ou KIND ` l’aide du symbole %. Ce proc´d´ s’applique ´galement aux
e
types intrins`ques :
subroutine sub( ch, len )
character(len=*), intent(inout) :: ch
integer, intent(in) :: len
real(selected_real_kind(9,99)), dimension(10) :: t
print *, len, ch%len, t%kind ! len(ch) ambigu ici, kind(t) possible.
end subroutine
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 133
a
Par analogie avec les tableaux ` taille implicite (assumed-size-array), lors d’une
e e e
d´claration, il est possible d’introduire le caract`re ∗ pour les param`tres ayant
e e
l’attribut LEN (assumed-type-parameter ). Cette forme peut ˆtre employ´e pour un
e
argument muet d’une proc´dure par exemple :
subroutine impression_champ( c )
type(champ_vecteur(k=selected_real_kind(9,99), d=*, n=*)) :: c
. . .
print *,c%d, c%n
end subroutine impression_champ
e e e e e
De mˆme, toujours pour ces param`tres, le caract`re : peut ˆtre utilis´
ıne e
(deffered-type-parameter ), comme pour la longueur d’une chaˆ de caract`res ou les
dimensions d’un tableau :
type(champ_vecteur(k=selected_real_kind(9,99), d=:, n=:)), pointer :: p
type(champ_vecteur(k=selected_real_kind(9,99), d=3, n=200)), target :: cible
. . .
p => cible
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 134
e
8.4 – Visibilit´ des composantes
e e e e e
En Fortran 95, un type d´riv´ pouvait seulement ˆtre public, priv´ ou semi-priv´ :
type struct_publique
integer :: i, j
real,dimension(160) :: tab
end type struct_publique
type, private :: struct_privee
integer :: i, j
real,dimension(160) :: tab
end type struct_privee
type struct_semi_privee
private
integer :: i, j
real,dimension(160) :: tab
end type struct_semi_privee
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 135
e
En Fortran 2003, la privatisation peut se g´rer plus finement au niveau de chaque
composante.
module m
type t
private
integer :: i
integer, public :: j
real :: k
end type t
. . .
end module m
program p
use m
type(t) obj
obj%i = ... e
! invalide : i est priv´ au module
obj%j = ... ! valide : j est publique
e
print *, obj%k ! invalide : k est priv´ au module
. . .
end program p
Remarque : les identificateurs i et k ne sont accessibles qu’au sein du module m.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 136
e e
8.5 – Extension d’un type d´riv´
e e ee c
Un type existant peut ˆtre enrichi. Pour cela, on d´finit un nouveau type en r´f´ren¸ant
e e
le type que l’on d´sire ´tendre au moyen de l’attribut EXTENDS.
type base_type
integer :: i
integer :: j
end type base_type
type, extends (base_type) :: my_type
real :: r
logical :: l
end type my_type
. . .
type(my_type) :: x
. . .
e
x%base_type%i = ... ! peut s’´crire : x%i = ...
x%r = ...
x%l = .false.
. . .
e ıt´
La notation x%base_type%i = ... pourrait s’av´rer utile pour lever une ambigu¨ e
e e
d’homonymie de nom de composantes apr`s h´ritage...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 137
e e
Extension d’un type param´tr´
e e e e e
Lorsqu’un type param´tr´ est ´tendu, le nouveau type h´rite des param`tres du type
e e
qu’il compl`te et peut en d´finir de nouveaux.
type champ_vect(n,d,k)
integer, kind :: k = kind(1.0)
integer, len :: d = 2, n
! - - - - - - - - - - - - -
real(kind=k), dimension(d,n) :: champ = 0.
end type champ_vect
type, extends(champ_vect) :: champ_vect_label(ln)
integer, len :: ln
! - - - - - - - -
character(len=ln) :: label=""
end type champ_vect_label
. . .
type(champ_vect_label(k=kind(1.d0), d=3, n=100, ln=30)) :: c1
. . .
c1 = champ_vect_label(k=kind(1.d0), d=3, n=100, ln=30)( label="champ de vitesses" )
. . .
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e e
8 – Types d´riv´s 138
Notes personnelles...
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 139
e
9 – Programmation orient´e objet
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 140
9.1 – Variable polymorphique
e
C’est une variable dont le type peut varier au cours de l’ex´cution. Celle-ci doit avoir
e
l’attribut POINTER ou ALLOCATABLE ou bien ˆtre un argument muet d’une proc´dure. e
e e e a
Pour sa d´claration, on sp´cifie le mot-cl´ CLASS ` la place de TYPE.
type point
real :: x, y
end type point
CLASS (point), pointer :: p
e ea a
Dans cet exemple, le pointeur p pourra ˆtre associ´ ` un objet de type point et ` toutes
e
les extensions ´ventuelles de ce type.
e e e e
Le type indiqu´ au niveau du mot-cl´ CLASS doit forc´ment ˆtre un type d´riv´ e e
e e e
extensible, ce qui exclut les types intrins`ques et les types d´riv´s pour lesquels on a
e e
pr´cis´ l’attribut sequence ou bind.
ea e e
On appelle declared type le type indiqu´ ` la d´claration au moyen du mot-cl´ CLASS et
e a e
dynamic type le type r´el de l’objet ` l’ex´cution.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 141
9.1.1 – Argument muet polymorphique
e a
Son type dynamique est celui de l’argument r´el fourni ` l’appel. Cela permet
a e e e
d’appliquer ` tous les types ´tendus une proc´dure d´finie pour le type de base.
module m
type point2d
real x, y
end type point2d
type, extends( point2d ) :: point2d_coul
real, dimension(3) :: compos_rvb
end type point2d_coul
type, extents( point2d ) :: point3d
real z
end type point3d
type, extends( point3d ) :: point3d_coul
real, dimension(3) :: compos_rvb
end type point3d_coul
contains
function distance( p1, p2 ) ! Calcul de la distance entre les points p1 et p2
CLASS(point2d) p1, p2
real distance
. . .
end function distance
end module m
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 142
9.1.2 – Variable polymorphique : attribut POINTER, ALLOCATABLE
Pointeur polymorphique : variable polymorphique ayant l’attribut POINTER ; son type
e e
dynamique est celui de sa cible qui peut ˆtre d´finie lors d’une association ou d’une
allocation dynamique (ALLOCATE).
e
De mˆme, le type dynamique d’une variable polymorphique ayant l’attribut
ALLOCATABLE est celui fourni lors de son allocation.
TYPE(point2d), target :: p2d
TYPE(point3d), target :: p3d
CLASS(point2d), pointer :: ptr2d_1, ptr2d_2
CLASS(point3d), pointer :: ptr3d
CLASS(point2d), allocatable :: point
ptr2d_1 => p2d ! Le type dynamique de ptr2d_1 est TYPE(point2d)
ptr2d_2 => p3d ! Le type dynamique de ptr2d_2 est TYPE(point3d)
ptr3d => p3d ! Le type dynamique de ptr3d est TYPE(point3d)
ptr2d_2 => ptr2d_1 ! Le type dynamique de ptr2d_2 est celui de ptr2d_1
ptr3d => ptr2d_1 ! Interdit
ALLOCATE( ptr2d_1 ) ! Alloue un objet de type dynamique TYPE(point2d)
! et associe ptr2d_1 avec.
ALLOCATE( TYPE(point3d)::ptr2d_2 ) ! Alloue un objet de type dynamique TYPE(point3d)
! et associe ptr2d_2 avec.
ALLOCATE( TYPE(point3d_coul) :: point )
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 143
9.2 – Construction SELECT TYPE
e
Cette construction permet l’ex´cution de blocs d’instructions en fonction du type
dynamique d’un objet polymorphique.
subroutine sp( a, b )
use m
CLASS(point2d) :: a, b
. . .
select type (a)
type is (point2d_coul)
. . .
class is (point3d)
. . .
class is (point3d_coul)
. . .
class default
. . .
end select
end subroutine sp
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 144
e e
C’est le type dynamique de l’objet a qui est analys´. La s´lection du bloc d’instructions
` ex´cuter se fait d’apr`s les r`gles suivantes :
a e e e
s’il existe une instruction TYPE IS correspondant au type, le bloc qui suit est
e e
ex´cut´,
sinon, s’il existe une seule instruction CLASS IS r´pondant au type, le bloc qui suit
e
e e
est ex´cut´,
sinon, s’il existe plusieurs instructions CLASS IS correspondant au type, c’est le
ee c e e
bloc de l’instruction CLASS IS r´f´ren¸ant le type le plus riche qui est ex´cut´,
sinon, s’il existe une instruction CLASS DEFAULT, c’est son bloc qui est ex´cut´.
e e
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 145
e e
9.3 – Pointeurs g´n´riques
e e e
Il est possible de d´finir un pointeur g´n´rique ou unlimited polymorphic pointer en
e e a e
pr´cisant le caract`re ∗ ` la place du nom du type au niveau du mot-cl´ CLASS. Celui-ci
e ea
peut ensuite ˆtre associ´ ` tout type de cible.
function func( p, ... )
CLASS(*), intent(in), pointer :: p
. . .
select type( p )
type is( selected_int_kind(9) )
. . .
type is( real )
. . .
type is( double precision )
. . .
type is( character(len=*) )
. . .
class default
print *,"Type invalide."
end select
end function func
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 146
9.4 – Type effectif d’une variable polymorphique
e e
Deux nouvelles fonctions intrins`ques permettent de d´terminer le type d’une variable
e
polymorphique au moment de l’ex´cution :
SAME_TYPE_AS ( a, b )
e
Retourne vrai si a et b ont le mˆme type dynamique.
EXTENDS_TYPE_OF ( a, mold )
Retourne vrai si le type dynamique de a est une extension de celui de mold.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 147
Exemple
function distance( p1, p2 )
CLASS(point2d) p1, p2
real distance
! Calcul de la distance entre les points p1 et p2
if ( SAME_TYPE_AS ( p1, p2 ) then
SELECT TYPE ( p1 )
CLASS IS (point2d)
distance = sqrt( (p2%x-p1%x)**2 + (p2%y-p1%y)**2 )
CLASS IS (point3d)
distance = sqrt( (p2%x-p1%x)**2 + (p2%y-p1%y)**2 + (p2%z-p1%z)**2 )
CLASS DEFAULT
print *,"Erreur : type non reconnu"; distance = -1.
END SELECT
else
e e
print *,"Erreur : les objets p1 et p2 doivent ^tre de m^me type"
distance = -2.
endif
end function distance
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 148
e e a
9.5 – Proc´dures attach´es ` un type (type-bound procedures)
e e e
Souvent, en programmation orient´e objet, on d´sire appeler une proc´dure pour
e
effectuer un traitement dont la nature d´pend du type dynamique d’un objet
e e a
polymorphique. Ceci est mis en œuvre au moyen de proc´dures attach´es ` un type
e e e e e a
d´riv´ (type-bound procedures) qui r´cup`rent en entr´e l’objet ` l’origine de l’appel
e
d´fini comme argument muet polymorphique. Celles-ci peuvent faire l’objet d’une
surcharge lors d’extensions du type.
e
Dans d’autres langages comme C++ on les appelle des m´thodes ou services ; leur
a e
invocation est vue comme l’envoi d’un message ` un objet dont la nature peut ˆtre
e a e a
r´solue ` l’ex´cution (polymorphisme dynamique) ou ` la compilation
(polymorphisme statique).
e e e e
Ce type de proc´dure peut ´videmment s’employer pour un type d´riv´ simple non
e
´tendu.
e e
Elles doivent ˆtre d´finies en contexte d’interface explicite.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 149
e e
9.5.1 – Proc´dure attach´e par nom (name binding )
module truc
type T
e
. . . !--> D´claration des composantes
e e
. . . !--> du type d´riv´ T
contains
PROCEDURE :: proc => my_proc
end type T
contains
subroutine my_proc(b, x, y)
type(T), intent(inout) :: b !--> Passed-object dummy argument
real, intent(in) :: x, y
. . .
end subroutine my_proc
end module truc
type(T) :: obj
real :: x1, y1
. . .
call obj%proc(x1, y1) !--> call my_proc(obj, x1, x2)
. . .
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 150
e e e e
9.5.2 – Proc´dure attach´e par nom g´n´rique (generic binding )
module m
type matrix(k, n, m)
integer, kind :: k
integer, len :: n, m
real(kind=k), dimension(n,m) :: A
contains
GENERIC :: max => max_4, max_8
end type matrix
contains
real(kind=4) function max_4( this )
class(matrix(k=4, n=*, m=*), intent(int) :: this
max_4 = MAXVAL( array=this%A )
end function max_4
real(kind=8) function max_8( this )
class(matrix(k=8, n=*, m=*), intent(int) :: this
max_8 = MAXVAL( array=this%A )
end function max_8
end module m
program prog
type(matrix(k=4, n=10, m=20) :: obj1; type(matrix(k=8, n=20, m=50) :: obj2
real(kind=4) max4; real(kind=8) max8
max4 = obj1%max()
max8 = obj2%max()
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 151
e e e
9.5.3 – Proc´dure attach´e par op´rateur (operator binding )
module m
type matrix(k, n, m)
integer, kind :: k
integer, len :: n, m
real(kind=k), dimension(n,m) :: A
contains
GENERIC :: OPERATOR(+) => add4, add8
GENERIC :: ASSIGNMENT(=) => affect4, affect8
end type matrix
contains
function add4( a, b )
class(matrix(k=4, n=*, m=*), intent(in) :: a, b
class(matrix(k=4, n=:, m=:), allocatable :: add4
if( shape(a%A) /= shape(b%A) ) stop "Erreur : objets non conformants"
allocate( matrix(k=4, n=a%n, m=a%m) :: add4 )
add4%A(:,:) = a%A(:,:) + b%A(:,:)
end function add4
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 152
function add8( a, b )
class(matrix(k=8, n=*, m=*), intent(in) :: a, b
class(matrix(k=8, n=a%n, m=a%m) :: add8
if( shape(a%A) /= shape(b%A) ) stop "Erreur : objets non conformants"
add8%A(:,:) = a%A(:,:) + b%A(:,:)
end function add8
!---------------------------------
subroutine affect4( a, b )
class(matrix(k=4, n=*, m=*), intent(inout) :: a
class(matrix(k=4, n=*, m=*), intent(in) :: b
if( shape(a%A) /= shape(b%A) ) stop "Erreur : objets non conformants"
a%A(:,:) = b%A(:,:)
end function affect4
!---------------------------------
subroutine affect8( a, b )
class(matrix(k=8, n=*, m=*), intent(inout) :: a
class(matrix(k=8, n=*, m=*), intent(in) :: b
if( shape(a%A) /= shape(b%A) ) stop "Erreur : objets non conformants"
a%A(:,:) = b%A(:,:)
end function affect8
end module m
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 153
program prog
use m
type(matrix(k=kind(0.d0), n=5, m=10)) :: mat1d, mat2d, mat3d
type(matrix(k=kind(0.), n=20, m=60)) :: mat1s, mat2s, mat3s
. . .
mat1s = mat2s + mat3s ! Appel ` add4 puis affect4
a
. . .
a
mat1d = mat2d + mat3d ! Appel ` add8 puis affect8
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 154
e e e
9.5.4 – Proc´dure attach´e via le mot-cl´ FINAL (final binding )
e e
C’est une proc´dure de type subroutine qui s’ex´cute lorsqu’un objet cesse d’exister.
e e a e e
Pour cela, au sein du type d´riv´ correspondant ` l’objet, on sp´cifie le mot-cl´ FINAL
e
auquel on associe une liste de sous-programmes (final subroutines) appel´s destructeurs.
e
Ceux-ci admettent un seul argument muet du type de celui d´fini.
e a
Pour un objet allou´ dynamiquement ` l’aide de l’instruction ALLOCATE, le destructeur
e e e
est appel´ au moment de sa d´sallocation effectu´e au moyen de l’instruction
DEALLOCATE.
e e
Pour un objet automatique, le destructeur est appel´ lorsque l’unit´ de programme, au
e e e
sein de laquelle l’objet est d´fini, est d´sactiv´e.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 155
module m
type t(k)
integer, KIND :: k
real(kind=k),pointer,dimension(:) :: v => null()
contains
FINAL :: finalize_scal , finalize_vect
end type t
contains
subroutine finalize_scal(x) !--> Arg. scalaire
type(t(k=4)) :: x
if( associated(x%v) ) deallocate(x%v)
end subroutine finalize_scal
subroutine finalize_vect(x) !--> Arg. vecteur
type(t(k=4)), dimension(:) :: x
do i=1,size(x)
if( associated(x(i)%v) ) deallocate(x(i)%v)
end do
end subroutine finalize_vect
end module m
e e e
Ainsi, lors de la d´sallocation de l’objet obj d´clar´ ainsi :
type(t(k=4)), dimension(:), allocatable :: obj
e e
c’est le destructeur finalize vect qui sera ex´cut´.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 156
e
9.6 – H´ritage
e e
9.6.1 – H´ritage d’une proc´dure type-bound
e e a e
Un type ´tendu d’un type extensible h´rite ` la fois de ses composantes mais ´galement
de ses proc´dures type bound.
e
module point
private
type, public :: point2d
real x, y
contains
PROCEDURE, PASS :: affichage => affichage_2d
end type
contains
subroutine affichage_2d ( this, texte )
CLASS(point2d), intent(in) :: this
CHARACTER(len=*), intent(in) :: texte
print *, texte
print *, "X = ", this%x
print *, "Y = ", this%y
end subroutine affichage_2d
end module point
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 157
e e
Voici un exemple d’h´ritage de proc´dure (ici affichage) :
module pointcoul
use point
private
type, public, extends(point2d) :: point2d_coul
real, dimension(3) :: compos_rvb
end type
end module pointcoul
!----------------------------
program prog
use pointcoul
type(point2d_coul) :: pcoul
e
call pcoul%affichage ( "Voici mes coordonn´es" )
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 158
e
9.6.2 – Surcharge d’une proc´dure type-bound
e e e
Lors de la d´finition d’un type ´tendu d’un type extensible il est possible d’´tendre ou
surcharger (override) les proc´dures type bound.
e
module pointext
use point
type, public, extends(point2d) :: point3d
real z
contains
PROCEDURE, PASS :: affichage => affichage_3d
end type
contains
subroutine affichage_3d( this, texte )
CLASS(point3d), intent(in) :: this
CHARACTER(len=*), intent(in) :: texte
call this%point2d%affichage( texte )
print *, "Z = ", this%z
end subroutine affichage_3d
end module pointext
program prog
use pointext
type(point3d) p
e
call p%affichage ( "Voici mes coordonn´es" )
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 159
e e a e
Dans les exemples pr´c´dents, les objets ` partir desquels les proc´dures type bound
e e e
sont appel´es sont d’un type fix´ : le compilateur sait alors quelle proc´dure appeler.
e e e e
Si l’on d´sire b´n´ficier du polymorphisme dynamique, on d´clare l’objet p de
e e
l’exemple pr´c´dent comme argument muet polymorphique. Cela permet d’appeler la
e a
proc´dure affichage correspondant au type dynamique de l’objet qui est ` l’origine de
l’appel.
program dynamic
use pointext
type(point2d) p2d
type(point3d) p3d
. . .
call affiche( p2d ); call affiche( p3d )
contains
subroutine affiche( p )
CLASS(point2d) , intent(in) :: p
e
call p%affichage ( "Voici mes coordonn´es" ) !--> Polymorphisme dynamique
end subroutine affiche
end program dynamic
a e e
La fonction affiche s’appliquera alors ` tout nouveau type ´tendu ult´rieurement
e a
d´fini sans avoir ` la recompiler.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet 160
e
9.6.3 – Proc´dure type-bound non surchargeable
a e e
L’attribut NON OVERRIDABLE ` la d´claration d’une proc´dure type-bound permet
e
d’interdire toute surcharge lors d’extensions ´ventuelles de ce type.
module m
type mycomplex
real theta, rho
contains
PROCEDURE, PASS, NON_OVERRIDABLE :: real => real_part
PROCEDURE, PASS, NON_OVERRIDABLE :: imag => imag_part
end type
contains
function real_part( a )
class(mycomplex), intent(in) :: a
real real_part
real_part = a%rho*cos(a%theta)
end function real_part
function imag_part( a )
class(mycomplex), intent(in) :: a
real imag_part
real_part = a%rho*sin(a%theta)
end function imag_part
end module m
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet : type abstrait 161
9.7 – Type abstrait
a e
C’est un type qui sert de base ` de futures extensions. Les proc´dures qui lui sont
e e e e e
attach´es doivent ˆtre d´clar´es avec l’attribut DEFFERED. La d´finition d’un tel type
e e
s’effectue en pr´cisant le mot-cl´ ABSTRACT.
e e
Il n’est pas possible de d´clarer des objets de ce type. Par contre, celui-ci peut ˆtre
e e
utilis´ pour la d´claration de variables polymorphiques.
e
L’extension d’un tel type peut se faire au moyen d’un type ´tendu normal ou d’un
nouveau type abstrait.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet : type abstrait 162
Voici un exemple :
module numerique
type, abstract :: mon_type_numerique
contains
private
procedure(func_oper), DEFFERED :: add
procedure(func_oper), DEFFERED :: mult
procedure(sub_oper), DEFFERED :: affect
generic, public :: operator(+) => add
generic, public :: operator(*) => mult
generic, public :: assignment(=) => affect
end type mon_type_numerique
abstract interface
function func_oper( a, b ) result(r)
class(mon_type_numerique), intent(in) :: a, b
class(mon_type_numerique), allocatable :: r
end function func_oper
subroutine sub_oper( a, b )
class(mon_type_numerique), intent(inout) :: a
class(mon_type_numerique), intent(in) :: b
end subroutine sub_oper
end interface
end module numerique
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
e
9 – Programmation orient´e objet : type abstrait 163
e e
Exemple de d´finition d’un type personnel mon entier h´ritant des ressources du type
e e
abstrait pr´c´dent.
module entier
use numerique
type, extends(mon_type_numerique) :: mon_entier
integer, private :: valeur
contains
procedure :: add => add_mon_entier
procedure :: mult => mult_mon_entier
procedure :: affect => affect_mon_entier
end type mon_entier
contains
e e
! D´finition des proc´dures :
! - add_mon_entier
! - mult_mon_entier
! - affect_mon_entier
end module entier
program prog
use entier
type(mon_entier) :: int1, int2, int3
. . .
e
int1 = int1*(int2 + int3) ! Implique l’appel aux proc´dures :
. . . ! add_mon_entier, mult_mon_entier puis affect_mon_entier
end program prog
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
10 – En conclusion 164
10 – En conclusion
La phase d’´laboration technique de la norme Fortran 2003 est termin´e ainsi que la
e e
phase ISO FCD (Final Committee Draft) dont le document
ISO-IEC/JTC1/SC22/WG5/N1578 (draft 04-007) est consultable en ligne ` a
l’adresse :
http://www.j3-fortran.org
a
` la rubrique Fortran 2003.
La norme Fortran 2003 est d´sormais officielle depuis septembre 2004.
e
En attendant l’arriv´e des premiers compilateurs Fortran 2003, certains fournisseurs
e
e
comme IBM, Nec, Nag, N.A. Software, ... int`grent progressivement certains
aspects de cette future norme.
´
INSTITUT DU DEVELOPPEMENT Fortran 2003 – Version 2.5 – 17 mars 2006
ET DES RESSOURCES
EN INFORMATIQUE SCIENTIFIQUE e
Patrick Corde, Herv´ Delouis
Index
– Symboles –
type-bound procedure : : generic binding . . . . . . . . . . . 150
bound procedure - surcharge . . . . . . . . . . . . . . . . . 158
type-bound procedure : : name binding . . . . . . . . . . . . . 149
type-bound procedure : : operator binding . . . . . . . . . . 151 –C–
type-bound procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 C ALERT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
C ASSOCIATED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
C BACKSPACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
–A– C CARRIAGE RETURN . . . . . . . . . . . . . . . . . . . . . . 15
C CHAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ABSTRACT INTERFACE . . . . . . . . . . . . . . . 123, 126 C DOUBLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ACCESS - STREAM . . . . . . . . . . . . . . . . . . . . . . . . . 104 C F POINTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
adresse cible : C LOC(X) . . . . . . . . . . . . . . . . . . . . . . 20 C F PROCPOINTER . . . . . . . . . . . . . . . . . . . . . . . . . . 21
affectation et allocation automatique . . . . . . 90, 91 C FLOAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ALLOCATABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 C FORM FEED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
allocatable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 C FUNLOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
ALLOCATABLE - argument de proc´dure . . . . . 86 e C FUNPTR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21, 45
ALLOCATABLE - composante type d´riv´ . . . . 88 e e C HORIZONTAL TAB . . . . . . . . . . . . . . . . . . . . . . . . 15
ALLOCATABLE - scalaire . . . . . . . . . . . . . . . . . . . . 89 C INT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ALLOCATABLE : argument INTENT(OUT) . . 87 C LOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20, 21, 47
ALLOCATABLE : argument SAVE . . . . . . . . . . . . 87 C LONG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
allocation via affectation . . . . . . . . . . . . . . . . . . . . . . 90 C NEW LINE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
e
argument de proc´dure : ALLOCATABLE . . . . . 86 C NULL CHAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
arguments - ligne de commande . . . . . . . . . . . . . . . 11 C PTR . . . . . . . . . . . . . . . . . . . . . . . . . 19–21, 45, 46, 50
arrondi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 C SHORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
e
association : pointeur de proc´dure . . . . . . . . . . . 118 C VERTICAL TAB . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
asynchrones - E./S. . . . . . . . . . . . . . . . . . . . . . . . . . . 102 calloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48, 51
ASYNCHRONOUS . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 e e
CHARACTER : interop´rabilit´ . . . . . . . . . . . . . . . 14
CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
–B– CLASS() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
CLOSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
BIND(C) . . . . . . . . . . . . . . . . . . . 18, 22, 23, 45, 46, 50 COMMAND ARGUMENT COUNT . . . . . . . . . . . . 11
bloc interface : IMPORT . . . . . . . . . . . . . . . . . . . . . . 96 e e
common : interop´rabilit´ . . . . . . . . . . . . . . . . . . . . . 18
164-1
composante ALLOCATABLE : destructeur . . . . 87 GENERIC : : ASSIGNMENT . . . . . . . . . . . . . . . . . 153
e e
constructeur de type d´riv´ . . . . . . . . . . . . . . . . . . 129 GENERIC : : OPERATOR . . . . . . . . . . . . . . . . . . . 153
generic binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
e e
generic binding : type d´riv´ . . . . . . . . . . . . . . . . . 150
–D– GET COMMAND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
GET COMMAND ARGUMENT . . . . . . . . . . . . . . . 11
e e
d´normalis´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
declared type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 GET ENVIRONMENT VARIABLE . . . . . . . . . . . . 11
DEFERRED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
descripteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
descripteur de format DT . . . . . . . . . . . . . . . . . . . . 106
h´ritage - proc´dure
e e
–. . .H . .–. . . . . . . . . . . . . . . . . 157
... .
destructeur : composante ALLOCATABLE . . . . 87
e e
destructeur type d´riv´ . . . . . . . . . . . . . . . . . . . . . . 154
e
division par z´ro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
DT - descripteur format . . . . . . . . . . . . . . . . . . . . . . 106
dtio-generic-pec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 IEEE
–I–
ALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67, 70–72
dynamic type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 IEEE ARITHMETIC . . . . . . . . . . . . . . . . . . . . . . . . . . 59
IEEE CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
IEEE CLASS TYPE . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
e
–E–
Entr´es/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
IEEE
IEEE
DIVIDE BY ZERO . . . . . . . . . . . . . . . . . . 66, 70
EXCEPTIONS . . . . . . . . . . . . . . . . . . . . . . . . . . 59
environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 IEEE FEATURES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
environnement - variables d’ . . . . . . . . . . . . . . . . . . . 12 IEEE GET FLAG . . . . . . . . . . . . . . . . . . . . . . . . . 68, 70
ERROR UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 IEEE GET HALTING MODE . . . . . . . . . . . . . . . . . 70
EXTENDS() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 IEEE GET ROUNDING MODE . . . . . . . . . . . . . . . 65
EXTENDS TYPE OF . . . . . . . . . . . . . . . . . . . . . . . . 146 IEEE GET STATUS . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
IEEE GET UNDERFLOW MODE(gradual) . . . 69
IEEE INEXACT . . . . . . . . . . . . . . . . . . . . . . . . . . . 66, 68
–F– IEEE
IEEE
INVALID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
IS FINITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
FINAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
final subroutine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 IEEE IS NAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
fonction C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47, 48, 51 IEEE IS NEGATIVE . . . . . . . . . . . . . . . . . . . . . . . . . . 62
IEEE IS NORMAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
IEEE NEGATIVE DENORMAL . . . . . . . . . . . 61, 64
–G–
GENERIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
IEEE
IEEE
NEGATIVE INF . . . . . . . . . . . . . . . . . . . . 61, 64
NEGATIVE NORMAL . . . . . . . . . . . . . . 61, 64
IEEE NEGATIVE ZERO . . . . . . . . . . . . . . . . . . 61, 64
164-2
IEEE OTHER VALUE . . . . . . . . . . . . . . . . . . . . . . . . 61 ISO C BINDING . . . . . . . . . . . . . . . . . . . . . . . 13, 20, 45
IEEE OVERFLOW . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 ISO FORTRAN ENV . . . . . . . . . . . . . . . . . . . . . . . . . . 12
IEEE POSITIVE DENORMAL . . . . . . . . . . . . 61, 64
IEEE POSITIVE INF . . . . . . . . . . . . . . . . . . . . . . 61, 64
IEEE POSITIVE NORMAL . . . . . . . . . . . . . . . 61, 64
IEEE POSITIVE ZERO . . . . . . . . . . . . . . . . . . . 61, 64
–K–
e e e
KIND : param`tre type d´riv´ . . . . . . . . . . . 127, 128
IEEE QUIET NAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 kind type parameters . . . . . . . . . . . . . . . . . . . . . . . . . 128
IEEE ROUND VALUE . . . . . . . . . . . . . . . . . . . . . . . . 65
IEEE SET FLAG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
IEEE SET HALTING MODE . . . . . . . . . . . . . . . . . . 70
IEEE SET ROUNDING MODE . . . . . . . . . . . . . . . . 65
e e e
–L–
LEN : param`tre type d´riv´ . . . . . . . . . . . . 127, 128
IEEE SET STATUS . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
length type parameters . . . . . . . . . . . . . . . . . . . . . . . 128
IEEE SET UNDERFLOW MODE(gradual) . . . . 69
ligne de commande : arguments . . . . . . . . . . . . . . . 11
IEEE SIGNALING NAN . . . . . . . . . . . . . . . . . . . . . . 61
IEEE STATUS TYPE . . . . . . . . . . . . . . . . . . . . . . . . . 72
IEEE SUPPORT DATATYPE . . . . . . . . . . . . . 60, 64
IEEE SUPPORT DENORMAL . . . . . . . . . . . . . . . . 60 –M–
IEEE SUPPORT INF . . . . . . . . . . . . . . . . . . . . . . . . . 60 e
module : importation d’entit´s . . . . . . . . . . . . . . . . 96
IEEE SUPPORT NAN . . . . . . . . . . . . . . . . . . . . . . . . 60 e
module : protection d’entit´s . . . . . . . . . . . . . . . . . . 95
IEEE SUPPORT STANDARD . . . . . . . . . . . . . . . . . 60 e
module : renommage d’op´rateurs . . . . . . . . . . . . . 97
IEEE UNDERFLOW . . . . . . . . . . . . . . . . . . . . . . . . . . 66 module : USE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
IEEE UP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 MOVE ALLOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
IEEE USUAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
IEEE VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62, 64
IMPORT : bloc interface . . . . . . . . . . . . . . . . . . . . . . 96
INPUT UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
–N–
NAME= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22, 23
INQUIRE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56, 57
INTENT - pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . 115 NON OVERRIDABLE . . . . . . . . . . . . . . . . . . . . . . . 160
INTENT(OUT) : argument ALLOCATABLE . . 87
interface implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Interface proc´dure Fortran . . . . . . . . . . . . . . . . . . . 22
e
e
interop´rabilit´ Fortran-C . . . . . . . . . . . . . . . . . 13, 18
e e
–O–
op´rateur : renommage via USE . . . . . . . . . . . . . . . 97
IOSTAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 e e
operator binding : type d´riv´ . . . . . . . . . . . . . . . . 153
IOSTAT END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 OPERATOR() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
IOSTAT EOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 OUTPUT UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
iso-IEC-1539 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
164-3
override - type bound procedure . . . . . . . . . . . . . . 158 reprofilage et association . . . . . . . . . . . . . . . . 116, 117
e
–P–
param`tres d’un type d´riv´ . . . . . . . . . . . . . . . . . . 127
e e
–S–
SAME TYPE AS . . . . . . . . . . . . . . . . . . . . . . . . 146, 147
PASS, NOPASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 SAVE : argument ALLOCATABLE . . . . . . . . . . . . 87
POINTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 scalaire : ALLOCATABLE . . . . . . . . . . . . . . . . . . . . . 89
e e
pointer : interop´rabilit´ . . . . . . . . . . . . . . . . . . . . . . 19 SELECT TYPE . . . . . . . . . . . . . . . . . . . . . . . . . 143, 147
pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 select type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
e
pointeur - proc´dure . . . . . . . . . . . . . . . . . . . . . . . . . 125 standard IEEE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56, 57
pointeur - reprofilage . . . . . . . . . . . . . . . . . . . . 116, 117 STREAM - ACCESS . . . . . . . . . . . . . . . . . . . . . . . . . 104
pointeur : vocation . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
pointeur C : valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 e e
structure : interop´rabilit´ . . . . . . . . . . . . . . . . . 46, 50
e
pointeur de proc´dure . . . . . . . . . . . 21, 118–120, 123 structure C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
e
pointeur de proc´dure : association . . . . . . . . . . . 118 surcharge - type bound procedure . . . . . . . . . . . . 158
e e
pointeur g´n´rique . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
pointeur polymorphique . . . . . . . . . . . . . . . . . . . . . . 142
pointeurs : interop´rabilit´ . . . . . . . . . . . . . . . . . . . . 19
e e
polymorphique - pointeur . . . . . . . . . . . . . . . . . . . . 142
–T–
tableau dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 e e
tableaux : interop´rabilit´ . . . . . . . . . . . . . . . . . . . . . 18
POS - READ/WRITE . . . . . . . . . . . . . . . . . . . . . . . . 104 tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . 90
e e
PRIVATE - type d´riv´ . . . . . . . . . . . . . . . . . . . . . . 134 toward +∞ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
e
proc´dure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 toward −∞ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
e
proc´dure - pointeur . . . . . . . . . . . . . . . . . . . . . . . . . 125 toward nearest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
e
proc´dure : pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 toward zero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
e
proc´dure : pointeur de . . . . . . . . . . . . . 118–120, 123 traitement des interruptions . . . . . . . . . . . . . . . . . . . 70
PROCEDURE : attribut . . . . . . . . . . . . 119, 120, 123 traitement exception . . . . . . . . . . . . . . . . . . . . . . . . . . 68
PROCEDURE() - attribut pointeur . . . . . . . . . . 123 type abstrait . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
PROTECTED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 type bound procedure . . . . . . . . . . . . . . . . . . . . . . . . 157
e e
PUBLIC - type d´riv´ . . . . . . . . . . . . . . . . . . . . . . . . 134 e e
type d´riv´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
e e
type d´riv´ : composante ALLOCATABLE . 87, 88
e e
type d´riv´ : constructeur . . . . . . . . . . . . . . . . . . . . 129
–R–
e
r´allocation et affectation automatique . . . . 90, 91
e
type d´riv´ : destructeur . . . . . . . . . . . . . . . . . . . . . 154
e
e
e
type d´riv´ : E./S. . . . . . . . . . . . . . . . . . . . . . . 105, 106
e
r´allocation via affectation . . . . . . . . . . . . . . . . . . . . 90 e e
type d´riv´ : GENERIC . . . . . . . . . . . . . . . . . . . . . . 105
READ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 e e
type d´riv´ : generic binding . . . . . . . . . . . . . . . . . 150
164-4
e e
type d´riv´ : operator binding . . . . . . . . . . . . . . . . 153
e e e
type d´riv´ : param`tre KIND . . . . . . . . . . . 127, 128
e e e
type d´riv´ : param`tre LEN . . . . . . . . . . . . 127, 128
e e e
type d´riv´ : param`tres . . . . . . . . . . . . . . . . . . . . . 127
e e
type d´riv´ : PRIVATE . . . . . . . . . . . . . . . . . . . . . . 134
e e
type d´riv´ : PUBLIC . . . . . . . . . . . . . . . . . . . . . . . . 134
e e e
type d´riv´ : visibilit´ . . . . . . . . . . . . . . . . . . . . . . . . 134
TYPE IS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
typedef struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48, 51
–U–
underflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57, 58
e
USE - module, renommage op´rateur . . . . . . . . . . 97
–V–
e
valeurs sp´ciales . . . . . . . . . . . . . . . . . . . . . . . . . . . 56, 57
VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46, 50
VALUE : attribut . . . . . . . . . . . . . . . . . . . . . . . . . . 22, 23
variable d’environnement . . . . . . . . . . . . . . . . . . . . . . 12
variable polymorphique . . . . . . . . . . . . . . . . . . . . . . 140
variable polymorphique : ALLOCATABLE . . . 142
variable polymorphique : argument muet . . . . . 141
variable polymorphique : POINTER . . . . . . . . . . 142
e e e
visibilit´ : type d´riv´ . . . . . . . . . . . . . . . . . . . . . . . . 134
void . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
–W–
WAIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Working draft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2, 164
WRITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
164-5
