Les Evolutions du Fortran 90/95.

B. Nkonga,
Projet ScAlApplix INRIA Futurs, Universit e Bordeaux 1
Cours a Yaound, 15-25 Juillet 2007 p.1
Plan
Introduction
Dclaration des variables
Les pointeurs
Les schmas de dcision et les schmas itratifs
Maintenabilit + Rutilisabilit = Modularit
Les interfaces
Visibilit
Vers le Fortran 95/2000/2003
Cours a Yaound, 15-25 Juillet 2007 p.2
Introduction
Cours a Yaound, 15-25 Juillet 2007 p.3
Un peu dhistoire
1954 IBM avec John Backus publie la description dun
systme de FORmulation mathmatique TRANspose.
1956 Premier manuel de rfrence qui dni le
Fortran I.
1957 Fortran II avec lapparition des procdures et la
compilation spare.
1962 Fortran IV (Fortran III est rest interne IBM)
introduit le type explicite. Il sera rebatis Fortran 66.
1978 Fortran 77 (lre moderne) propose une avance
signicative dans les entrs sorties avec le format libre
et linstruction OPEN.
Cours a Yaound, 15-25 Juillet 2007 p.4
. . . Un peu dhistoire
1991 Fortran 90 quelques facilits de la programmation
objets, le calcul matriciel, le contrle de la prcision
numrique, ...
2000 Fortran 95, introduction de notion de paralllisme
de donnes
200X Fortran 2000, programmation orient objets
Cours a Yaound, 15-25 Juillet 2007 p.5
Introduction au gnie logiciel (ou rappels)
La gnricit : Cest le fait pour un objet de pouvoir tre utilis tel quel dans
diffrents contextes (ou mme indpendamment du contexte).
Outils: INTERFACE, MODULE PROCEDURE, OPTIONAL, POINTER
La modularit : La partie la plus importante de lcriture de programmes
consiste les structurer pour les prsenter comme un assemblage de briques qui
semboitent naturellement. Ce problme est fondamental d la taille consquente
des programmes. La modularit est le fait de structurer un programme en modules
indpendants rduisant le cot de la compilation spare et de la reconstruction
incrmentale, tout en maintenant des possibilits dvolutions.
Outils: MODULE, CONTAINS, les types drivs, structures, dpendances.
Lencapsulation : Lencapsulation consiste rassembler des donnes et/ou des
objets au sein dune structure en masquant limplmentation de lobjet. Il permet aussi
de garantir lintgrit des donnes contenues dans lobjet.
Outils: PUBLIC, PRIVATE, ONLY, USE, =>
Cours a Yaound, 15-25 Juillet 2007 p.6
Introduction au gnie logiciel
Le polymorphisme : signie que les diffrentes mthodes dune opration ont
la mme signature. Lorsque une opration est invoque sur un objet, celui-ci connait
sa classe et par consquent est capable dinvoquer automatiquement la mthode
correspondante. Pour quune nouvelle classe supporte une opration existante il lui
suft de fournir la mthode correspondante sans avoir se soucier des autres
mthodes dj dnies.
Outils: INTERFACE, MODULE PROCEDURE, OPTIONAL
La recurcivit : Cest le fait pour un objet (programme ou une procdure) de
sappeler au moins une fois lui-mme. Il permet de rsoudre de faon lgante
certains problmes, soit par limplmentation, soit par le simple fait de penser le
problme en terme de rcursivit.
Outils : RECURSIVE, RESULT, les pointeurs.
Cours a Yaound, 15-25 Juillet 2007 p.7
Introduction au gnie logiciel : le module
Un module est un lment de petite taille (en gnral un ou quelques sous-programmes) qui
sert, par assemblage, la construction de logiciels. Un module doit tre cohrent et
autonome. Un module rend des services ou effectue des traitements. Pour exploiter un
module dans un logiciel, il est ncessaire davoir une description prcise de ce quil fait, ce
qui, dans la pratique se traduit par le passage dinformation travers son interface. De ce
point de vue, on peut dire quun module est dni par son interface. Do les principes de la
modularit:
Dnir des interfaces explicites chaque fois que deux modules changent des
informations.
Masquer le plus dinformation possible. Seules les informations qui servent la
communication avec dautres modules doivent tre publiques (visibles de lextrieur du
module).
Un module doit communiquer avec aussi peu dautres modules que possible.
Units linguistiques modulaires : les modules doivent correspondre des units
syntaxiques du langage.
Cours a Yaound, 15-25 Juillet 2007 p.8
Structuration dun programme en F90/95.
La ncessit de dcomposer un programme en plusieurs parties est maintenant admise. En
Fortran 90/95 chacune de ces parties, appele unit de programmation, est compilable
sparment mais en respectant les dpendances.
Il existe trois units de programmation :
Le programme principal
PROGRAM Toto
CONTAINS
END PROGRAM Toto
La procdure externe
SUBROUTINE Titi(les args)
CONTAINS
END SUBROUTINE Titi
FUNCTION Titi(les args)
CONTAINS
END FUNCTION Titi
Cours a Yaound, 15-25 Juillet 2007 p.9
Le module
MODULE Tata
CONTAINS
END MODULE Tata
Un programme contient au moins lunit programme
principal.
programme = chier
unit de progammation = chier
Cours a Yaound, 15-25 Juillet 2007 p.10
Le cadre de programmation : Format libre
La ligne de programme comporte au plus 132 caractres.
Les caractres blancs sont signicatifs, sauf en dbut de ligne
IF (LaVar.eq.0) THEN et I F (La Var.eq.0) TH EN
Une ligne de programme peut dcrire plusieurs instructions si celles-ci sont spares
par ;
a=3 ; b=4
c=8 ; write(
*
,
*
) a
*
b
*
c
Une instruction peut tre dcrite sur plusieurs lignes (39 au plus) nissant par "&", sauf
la dernire
a=38+c
*
&
& d+b
Dans le passage la ligne dans lexpression dune chane de caractre la suite de la
chane doit tre prcde par "&"
MaString=bonjour&
& la formation est bien?
MaString=bonjour&
& la formation est bien?
Cours a Yaound, 15-25 Juillet 2007 p.11
Le cadre de programmation : Format libre
le caractre ! marque le dbut dun commentaire qui se termine toujours la n de la
ligne. Il ny a pas de restriction sur les caractres utiliss dans un commentaire car
ceux-ci sont sans effets. Par consquent,
un commentaire ne peut avoir de suite,
un commentaire ne peut tre intercal entre des lignes suites.
! on affecte 3 a la variable A
A=3
B=4 ! on affecte 4 a la variable B
Cours a Yaound, 15-25 Juillet 2007 p.12
lAlphabet
Les 37 caractres alphanumriques
(26 lettres, 10 chiffres et le souligneur) :
a b c d e f g h i j k l m
n o p q r s t u v w x y z
0 1 2 3 4 5 6 7 8 9 _
Il y a quivalence entre minuscule et majuscule
Les 21 caractres spciaux :
+ -
*
/ < > . , = ( )
: ! " % & ; ? blanc $
Cours a Yaound, 15-25 Juillet 2007 p.13
Les lments lexicaux
Ils sont composs dau plus 31 caractres
alphanumriques dont le premier doit tre une lettre.
Les mots clefs : Ce sont les noms communs du langage
DO END WHILE MODULE INTEGER MINVAL
Les identicateurs : Ce sont les noms propres choisis par
le programmeur pour dsigner les entits de son
programme
de variables,
de programmes, de procdures, de modules,
de types drivs,
dinterfaces gnriques, etc.
Cours a Yaound, 15-25 Juillet 2007 p.14
Les Oprateurs
Oprateurs arithmtiques
+ -
*
/
**
a = b + c
*
b
**
2
Oprateurs de comparaison
== /= IF (a==3) THEN
Oprateurs dordre (uniquement numrique)
< > <= >= IF (a<=3) THEN
Oprateurs logiques
.NOT. .AND. .OR. .EQV. .NEQV.
IF (.NOT.(a==3).AND.(MyString/=bonjour)) THEN
Oprateur de concatnation
// print
*
, "Bon" // "jour"
Cours a Yaound, 15-25 Juillet 2007 p.15
Sparateurs et dlimiteurs
les sparateurs
& , : ; = % :: =>
REAL :: x, Pi, Tab(5)
les dlimiteurs
/.../ (...) (/.../) "....."
Tab(1:5) = (/1, 4, 200, 300, 3/)
Cours a Yaound, 15-25 Juillet 2007 p.16
Les tiquettes
Les tiquettes sont utilises pour rfrencer une instruction
ou un bloc dinstructions.
Pour rfrencer une instruction, ltiquette est
compose dau plus 5 chiffres situe en dbut de
linstruction.
100 FORMAT( E15.8 )
Pour rfrencer un bloc dinstruction, ltiquette est
compose dun identicateur en dbut de bloc suivie du
sparateur : puis du bloc dinstruction.
MaBoucle : DO i = 1, 10
T(i) = i
END DO MaBoucle
Cours a Yaound, 15-25 Juillet 2007 p.17
Les instructions excutables
[etiquette] mot-cle [corps]
Laffectation
ObjetFinal = expression_evaluable
lappel une procdure
CALL MyProcedure(les arguments)
les I/O
WRITE(6,
*
) SinPi(x)
les formats
100 FORMAT( E15.8 )
RETURN, STOP
Cours a Yaound, 15-25 Juillet 2007 p.18
Les Atomes
Les types intrinsques
Numriques : INTEGER, REAL, COMPLEX
Boolens : LOGICAL
Chanes de caractres : CHARACTER
Les oprateurs intrinsques
Scalaires +, -,
*
,
**
, /, ==, >, <, >=, <=,
Boolens .AND. , .OR. , .NOT.
Chanes de caractres//, ==
Affectation =
Quelques attributs : PARAMETER, DIMENSION(:,:), ALLOCATABLE,
POINTER, TARGET, SAVE, SEQUENCE, INTENT(IN/OUT/INOUT),
PUBLIC, PRIVATE, EXTERNAL, INTRINSIC
Quelques Mots clefs:
PROGRAM, SUBROUTINE, FUNCTION, MODULE, USE, CALL, CONTAINS,
PUBLIC , PRIVATE, PURE, ELEMENTAL, END, DO, ELSE, IF, SELECT,
CASE, EXIT, CYCLE, WHILE
Cours a Yaound, 15-25 Juillet 2007 p.19
Les Organes
Les fonctions intrinsques
Scalaires: MAX, MIN, EXP, SIN, COS, MOD
Tableaux:
MAX, MIN, EXP, SIN, COS, SUM, MATMUL
Boolens: PRESENT, ASSOCIATED
Chanes de caractres: TRIM, LEN, TRIM_LEN
Les procdures utilisateur,
Les fonctions utilisateur,
Les modules utilisateur.
Cours a Yaound, 15-25 Juillet 2007 p.20
Dclaration des variables
Cours a Yaound, 15-25 Juillet 2007 p.21
F90/95 : Dclaration des variables
type [les attributs] :: liste des objets
TYPENUM[(param`etres)], [les attributs] :: liste des vars
LOGICAL, [les attributs] :: liste des vars
CHARACTER(taille[,param`etres]), [les attributs] :: liste des vars
Exemples:
INTEGER , PARAMETER :: Ns=100, Nt=200
REAL(8) , PRIVATE :: pi = 3.14
REAL(4) , TARGET, SAVE :: x
REAL(8) , INTENT(IN) :: Z
COMPLEX(8), DIMENSION(Ns,3):: ChampsI, ChampsR
LOGICAL , DIMENSION(Nt) :: Bol
CHARACTER(LEN=10), PUBLIC :: VigieName, NetCdfName
CHARACTER(10,KIND(1)) :: VigieName2, NetCdfName2 ! jeu ascii
Cours a Yaound, 15-25 Juillet 2007 p.22
Dnitions de quelques attributs
PARAMETER Dnit des constantes symbol-
iques
DIMENSION Dnit la forme (explicite ou im-
plicite), la taille (explicite, implicite ou
diffre) et le rang dun tableau
POINTER Dnit les objets dynamiques.
PUBLIC Donne laccessibilit des com-
posantes dun Module aux units qui
lui font appel par linstruction USE.
OPTIONAL permet de dnir des arguments
optionnels lappel dune procdure.
SAVE Dnit des variables rmanentes
dans une procdure. La zone m-
moire rserve cette variable est
prserve dun appel lautre.
ALLOCATABLE Diffre la rservation de
lespace mmoire lutilisation de
linstruction ALLOCATE
TARGET Dnition des variables cibles po-
tentiels dobjets dynamiques.
SEQUENCE interdit de changer lordre des
composantes dune structure.
PRIVATE Limite laccessibilit des com-
posantes dun module lui mme.
INTENT Protge laccs aux arguments
dune procdure en leur donnant une
vocation : IN, OUT, INOUT.
EXTERNAL Identie les noms de proc-
dures externes transmis comme argu-
ments une procdure.
Cours a Yaound, 15-25 Juillet 2007 p.23
F90/95 : Matrise de la prcision Numrique
TYPENUM(KIND=Param`etre) :: les variables
TYPENUM est la notation gnriques pour les types
intrinsques numriques : INTEGER, REAL, COMPLEX.
Le paramtre est un entier qui peut sobtenir en utilisant
des fonctions intrinsques.
SELECTED_INT_KIND(R) : fonction qui donne la valeur du
paramtre du type entier permettant de reprsenter une entier, X, avec |X| < 10
r
SELECTED_REAL_KIND(P,R) : fonction qui donne la valeur
du paramtre du type rel permettant de reprsenter un rel, X, avec p chiffres
signicatifs et |X| < 10
r
KIND(X) : fonction qui donne la valeur du paramtre du type X.
Cours a Yaound, 15-25 Juillet 2007 p.24
F90/95 : Matrise de la prcision Numrique
Exemples de dclaration
dclaration dun entier dau moins 10 chiffres :
INTEGER, PARAMETER :: MyIntg0 = SELECTED_INT_KIND(10)
INTEGER(MyIntg0) :: I
dclaration dun rel compris entre 10
20
et 10
20
avec 7 chiffres dcimaux :
INTEGER, PARAMETER :: MyReal0 = SELECTED_REAL_KIND(P=7,R=20)
REAL(MyReal0) :: X
dclaration de la prcision des rels et des entiers
INTEGER, PARAMETER :: MyReal=KIND(1.D0), MyIntg=KIND(1)
INTEGER(MyIntg) :: I
REAL(MyReal) :: X
dclaration des complexes avec la mme prcision que pour les rels
REAL(KIND=MyReal) :: X; COMPLEX(KIND=MyReal) :: Cx
Cours a Yaound, 15-25 Juillet 2007 p.25
F90/95 : Matrise de la prcision Numrique
accs aux limites de prcision
EPSILON(X) cart relatif maximal entre deux rels de type X:
X(1 ) > X < X(1 +)
HUGE(X) plus grande valeur reprsentable dans le type X
TINY(X) plus petite valeur reprsentable dans le type X
IInfini = HUGE(1_MyInt); RInfini = HUGE(1_MyReal)
REps = EPSILON(1_MyReal)
Cours a Yaound, 15-25 Juillet 2007 p.26
F90/95 : Matrise de la prcision Numrique
PROGRAM PrecisionS
INTEGER, PARAMETER :: MyReal=KIND(1.0), MyIntg=KIND(1)
INTEGER, PARAMETER :: MyReal4=KIND(1.E0),MyReal8=KIND(1.D0)
INTEGER, PARAMETER :: MyRealM=SELECTED_REAL_KIND(19,90)
PRINT
*
, " Infini Entier =", HUGE(1_MyIntg)
PRINT
*
, "
*****************
REAL par defaut
******************
"
PRINT
*
, " Infini Reel =", HUGE(1.0_MyReal)
PRINT
*
, " Eps Relatif Reel =", EPSILON(1.0_MyReal)
PRINT
*
, " Zero Reel =", TINY(1.0_MyReal)
PRINT
*
, " Precision 10-E =", PRECISION(1.0_MyReal)
PRINT
*
, "
*****************
REAL par defaut 1.E0
******************
"
PRINT
*
, " Infini Reel =", HUGE(1.0_MyReal4)
PRINT
*
, " Eps Relatif Reel =", EPSILON(1.0_MyReal4)
PRINT
*
, " Zero Reel =", TINY(1.0_MyReal4)
PRINT
*
, " Precision 10-E =", PRECISION(1.0_MyReal4)
Cours a Yaound, 15-25 Juillet 2007 p.27
F90/95 : Matrise de la prcision Numrique
PRINT
*
, "
*****************
REAL par defaut 1.D0
******************
"
PRINT
*
, " Infini Reel =", HUGE(1.0_MyReal8)
PRINT
*
, " Eps Relatif Reel =", EPSILON(1.0_MyReal8)
PRINT
*
, " Zero Reel =", TINY(1.0_MyReal8)
PRINT
*
, " Precision 10-E =", PRECISION(1.0_MyReal8)
PRINT
*
, "
*****************
REAL SELECTED_REAL_KIND(6,70)
************
"
PRINT
*
, " Infini Reel =", HUGE(1.0_MyRealM)
PRINT
*
, " Eps Relatif Reel =", EPSILON(1.0_MyRealM)
PRINT
*
, " Zero Reel =", TINY(1.0_MyRealM)
PRINT
*
, " Precision 10-E =", PRECISION(1.0_MyRealM)
END PROGRAM PrecisionS
Cours a Yaound, 15-25 Juillet 2007 p.28
F90/95 : Matrise de la prcision Numrique
Rsulats obtenus avec le programme prcdent sur un ES45
Infini Entier = 2147483647
*****************
REAL par defaut
******************
Infini Reel = 3.4028235E+38
Eps Relatif Reel = 1.1920929E-07
Zero Reel = 1.1754944E-38
Precision 10-E = 6
*****************
REAL par defaut 1.E0
******************
Infini Reel = 3.4028235E+38
Eps Relatif Reel = 1.1920929E-07
Zero Reel = 1.1754944E-38
Precision 10-E = 6
Cours a Yaound, 15-25 Juillet 2007 p.29
F90/95 : Matrise de la prcision Numrique
*****************
REAL par defaut 1.D0
******************
Infini Reel = 1.797693134862316E+308
Eps Relatif Reel = 2.220446049250313E-016
Zero Reel = 2.225073858507201E-308
Precision 10-E = 15
*****************
REAL SELECTED_REAL_KIND(6,70)
************
Infini Reel = 1.189731495357231765085759326628007E+4932
Eps Relatif Reel = 1.925929944387235853055977942584927E-0034
Zero Reel = 3.362103143112093506262677817321753E-4932
Precision 10-E = 33
Cours a Yaound, 15-25 Juillet 2007 p.30
Les Tableaux
TYPE, DIMENSION(taille1,taille2,...) :: MonTab
rang limit 7
borne infrieure par dfaut: 1
REAL, DIMENSION(3) :: MonTab1
REAL, DIMENSION(-1:3) :: MonTab2
REAL, DIMENSION(5:7) :: MonTab3
Sous tableaux : Tab(j1:jN:jPas, k1:kN:kPas, ...)
les composantes sont ranges en mmoire des adresses conscutives (colonnes
par colonnes).
Remarque : non garantie pour les sous-tableaux.
vecteurs anonymes et pseudo-boucles : (/ /)
REAL, DIMENSION(3) :: MonTab1=(/0,1,2/)
REAL, DIMENSION(3) :: MonTab2=(/i
**
2,i=4,6/)
MonTab2(1)=16 MonTab2(2)=25 MonTab2(3)=36
Cours a Yaound, 15-25 Juillet 2007 p.31
Les Molcules: Les Tableaux Statiques
type, DIMENSION(10) :: Tab
type, DIMENSION(Ns,10) :: Tab1
Ns est une constante symbolique de type entier.
Dclaration
Les tableaux de type numrique:
REAL, DIMENSION(10) :: Tab
De boolens:
LOGICAL, DIMENSION(10) :: Tab
De chanes de caractres:
CHARACTER(LEN=5), DIMENSION(10) :: Tab
Les lments dun tableau sont contigus en mmoire.
Cours a Yaound, 15-25 Juillet 2007 p.32
Les Types-drivs
Ils permettent de dnir des structures de donnes
complexes
Dnition dun type-driv.
TYPE [Attribut du TYPE ::] Nom_du_type
[Attribut des composants]
type [les attributs des champs] :: les champs
END TYPE [Nom_du_type]
Les attributs du type : PUBLIC, PRIVATE.
Les attributs des composantes :
SEQUENCE, PUBLIC, PRIVATE.
Les attributs proscrits pour les champs sont:
PARAMETER, ALLOCATABLE, TARGET, SAVE, OPTIONAL, PRIVATE, PUBLIC
Cours a Yaound, 15-25 Juillet 2007 p.33
Les Types drivs privs
La diffrence entre ces deux dclarations.
On naccde pas au type en dehors de la porte
TYPE, PRIVATE :: POINT3D
REAL(8), DIMENSION(3) :: pos
END TYPE POINT3D
on naccde pas aux composants du type en dehors
de la porte. On parle alors de type abstrait.
TYPE POINT3D
PRIVATE
REAL(8), DIMENSION(3) :: pos
END TYPE POINT3D
Cours a Yaound, 15-25 Juillet 2007 p.34
Types drivs : exemples
! Les sommets en 2D
TYPE Point
REAL(8) :: X,Y
END TYPE Point
!La connectivite dun triangle
TYPE Triangle
INTEGER(KIND(1)) :: S1,S2,S3
END TYPE Triangle
! Le maillage geometrique
TYPE Maillage2D
Point, DIMENSION(200) :: Noeuds
Triangle, DIMENSION(150) :: Connectivite
END TYPE Maillage2D
Cours a Yaound, 15-25 Juillet 2007 p.35
Les Types-drivs statiques
Exemples
TYPE Maillage
INTEGER(KIND=MyIntg) :: Ns=10, Nt=20
INTEGER(KIND=MyIntg), DIMENSION(10) :: LogN
INTEGER(KIND=MyIntg), DIMENSION(3,20):: Nu
REAL(KIND=MyReal) , DIMENSION(2,20):: Coor
COMPLEX(KIND=MyReal), DIMENSION(2,20):: Z
END TYPE Maillage
TYPE LesChamps
COMPLEX(KIND=MyReal), DIMENSION(3,200):: Ex
COMPLEX(KIND=MyReal), DIMENSION(3,200):: Ey
COMPLEX(KIND=MyReal), DIMENSION(3,200):: Ez
END TYPE LesChamps
Cours a Yaound, 15-25 Juillet 2007 p.36
Les Molcules: Les Structures Statiques
Cration de structures statiques:
TYPE(Maillage) :: Niveau0
TYPE(Maillage), PRIVATE :: NiveauL
Les Tableaux statiques de structures statiques:
TYPE(Maillage), DIMENSION(Ns) :: Hyb
TYPE(Maillage), DIMENSION(10,100) :: HybS
Accs aux composantes: le slecteur %
Niveau0%Coor(1,2) = 0.7_MyReal
HybS(1,2)%Coor(1,2) = 0.3_Myreal
Niveau0%Z(1,2) = (0._MyReal, 7._MyReal)
Cours a Yaound, 15-25 Juillet 2007 p.37
Les Cellules : Objets Dynamiques
Objets allocation diffre
type, ALLOCATABLE :: ScaDyn
type, ALLOCATABLE, DIMENSION(:) :: TabD
type, ALLOCATABLE, DIMENSION(:,:) :: TabDyn
La rservation de la mmoire nest effective quavec linstruction ALLOCATE et la
libration de cet espace quavec linstruction DEALLOCATE
ALLOCATE( ScaDyn, TabD(1:200), TabDyn(-1:200,0:200) )
TabD=(/ (2.0
*
i, i = 0, 199) /)
DEALLOCATE( TabD )
...
READ
*
, n
ALLOCATE( TabD(1:n), stat = err )
if( err /=0 ) THEN
TabD=(/ (2.0
*
i, i = 0, n) /)
ENDIF
Cours a Yaound, 15-25 Juillet 2007 p.38
Les Cellules : Objets Dynamiques
Tableaux dimension automatique, pour des arguments de procdures:
type, DIMENSION(:,:) , INTENT(IN) :: TabDyn
type, DIMENSION(-1:,0:) , INTENT(IN) :: TabDyn
type, DIMENSION(-1:,-2:), INTENT(IN) :: TabDyn
Nx=SIZE(TabDyn, DIM=1) ; Ny=SIZE(TabDyn, DIM=2)
i0=LBOUND(TabDyn,DIM=1); j0=LBOUND(TabDyn,DIM=2)
iN=UBOUND(TabDyn,DIM=1); jN=UBOUND(TabDyn,DIM=2)
-----------------------------------------------------------
a) Nx=202 Ny=201 i0=1 j0=1 iN=202 jN=201
b) Nx=202 Ny=201 i0=-1 j0=0 iN=200 jN=200
c) Nx=202 Ny=201 i0=-1 j0=-2 iN=200 jN=198
Tableaux (TabLoc) locaux une procdure, de taille dpendant de celle dun argument
de la procdure.
type, DIMENSION(-1:,0:) , INTENT(IN) :: TabDyn
type, DIMENSION(SIZE(TabDyn,DIM=1)) :: TabLoc
Cours a Yaound, 15-25 Juillet 2007 p.39
Les pointeurs
Cours a Yaound, 15-25 Juillet 2007 p.40
Les Pointeurs
Cration dun pointeur
type, POINTER [ autres attributs] :: Alias
type, POINTER [ autres attributs] :: Alias=>NULL()
dans le premier cas Alias est dans un tat indtermin, dans le second cas il est
dans ltat libre.
Assignation dun pointeur libre : Alias => Cible
Cible est un objet du mme type et de mme forme que Alias, ayant lattribut
TARGET ou POINTER.
Rompre toute assignation du pointeur: NULLIFY(Alias).
Cration dune cible anonyme et assignation sur cette cible : ALLOCATE(Alias).
Pour rompre lassociation dans ce cas on utilise linstruction DEALLOCATE
Etat dassociation dun pointeur : ASSOCIATED(POINTER=Alias, TARGET=Cible),
retourne .TRUE. si Alias est associ avec Cible, .FALSE. sinon. Largument
TARGET est optionnel: ASSOCIATED(POINTER=Alias), retourne .TRUE. si Alias
est associ et .FALSE. sinon.
Cours a Yaound, 15-25 Juillet 2007 p.41
Pointeurs et passage en argument
Pointeur pass en argument dappel dune procdure.
Largument muet na pas lattribut pointer
le pointeur doit tre associ avant lappel,
cest ladresse de la cible associe qui est passe,
linterface peut tre implicite ce qui permet lappel dune procdure Fortran 77.
Attention : dans ce cas si la cible est une section rgulire non contigu, le
compilateur transmet une copie contigu, do un impact possible sur les
performances.
Largument muet a lattribut pointer
le pointeur nest pas ncessairement associ avant lappel (avantage par
rapport allocatable),
cest ladresse du descripteur du pointeur qui est passe,
linterface doit tre explicite (pour que le compilateur sache que largument
muet a lattribut pointer),
si le pointeur pass est associ un tableau avant lappel, les bornes
infrieures/suprieures de chacune de ses dimensions sont transmises la
procdure ; elles peuvent alors tre rcupres via les fonctions
UBOUND/LBOUND.
Cours a Yaound, 15-25 Juillet 2007 p.42
Pointeurs et passage en argument
Cible en argument dune procdure.
Lattribut target peut tre spci soit au niveau de largument dappel, soit au
niveau de largument muet, soit au niveau des deux. Il sagit dans tous les cas
dun passage dargument classique par adresse. Si largument muet a lattribut
target, linterface doit tre explicite.
Attention lutilisation des pointeurs globaux ou locaux permanents (save)
ventuellement associs dans la procdure cette cible dans le cas o le
compilateur aurait d faire une copie copy incopy out de largument dappel.
Dailleurs, dune faon gnrale, la norme ne garantit pas la conservation de
lassociation de pointeurs entre la cible passe en argument et celle
correspondant largument muet.
Cours a Yaound, 15-25 Juillet 2007 p.43
Procdures recursives
La rcursivit permet de dnir une procdure ou une
fonction capable de sappeler elle-mme.
Dnition dune procdure rcurcive:
RECURSIVE SUBROUTINE TriPartition( )
....
END SUBROUTINE TriPartition
Dnition dune fonction rcurcive
RECURSIVE FUNCTION Factoriel(n ) RESULT(m)
....
END FUNCTION Factoriel
Cours a Yaound, 15-25 Juillet 2007 p.44
Procdures recursives: Exemple
RECURSIVE FUNCTION Factoriel(n )RESULT(m)
INTEGER, INTENT(IN) :: n
INTEGER :: m
! -------------------------------------
IF( n == 0 ) THEN
m=1
ELSE
m=n
*
Factoriel(n-1)
END IF
END FUNCTION Factoriel
Cours a Yaound, 15-25 Juillet 2007 p.45
Structures dynamiques
Dnition dun type-driv ayant des composantes
dynamiques:
TYPE MaillageD
INTEGER(KIND=MyIntg) :: Ns, Nt, NsFr=0
INTEGER(KIND=MyIntg), DIMENSION(:) , POINTER :: LogN
INTEGER(KIND=MyIntg), DIMENSION(:) , POINTER :: LogFr
INTEGER(KIND=MyIntg), DIMENSION(:,:), POINTER :: Nu
INTEGER(KIND=MyIntg), DIMENSION(:,:), POINTER :: NuFr
REAL(KIND=MyReal) , DIMENSION(:,:), POINTER :: Coor
END TYPE MaillageD
Dnition de structures dynamiques:
TYPE(MaillageD) :: Niveau0
TYPE(MaillageD) , DIMENSION(:), ALLOCATABLE :: HybD1
TYPE(MaillageD), DIMENSION(:), ALLOCATABLE :: HybDD
Cours a Yaound, 15-25 Juillet 2007 p.46
Listes chanes
type-driv de la cellule lmentaire
TYPE Cell
(composantes)
TYPE(Cell), POINTER :: Suiv=>NULL()
END TYPE Cell
Tte de liste TYPE(Cell) :: Debut
Variable intermdiaire : TYPE(Cell), POINTER :: TheCell
Cration de la liste
ALLOCATE( TheCell ) ; Debut%Suiv=> TheCell
ALLOCATE( TheCell )
Debut%Suiv%Suiv => TheCell
Cours a Yaound, 15-25 Juillet 2007 p.47
Les schmas de dcision
Les schmas itratifs
Cours a Yaound, 15-25 Juillet 2007 p.48
Lalternative: bloc IF
Ralisation dinstructions sous condition
[nom:] IF( test_1 ) THEN
instructions
ELSE IF(test_2) THEN
instructions
ELSE
instructions
END IF [nom]
IF( a == 3 ) THEN
WRITE(
*
,
*
) a vaut 3
ELSE IF( a>3 ) THEN
WRITE(
*
,
*
) a plus grand que 3
ELSE
WRITE(
*
,
*
) a plus petit que 3
END IF
Les blocs IF peuvent tre emboits
Bloc IF sur une ligne :
IF( test_1 ) instruction IF ( A < 0 ) A = -A
Cours a Yaound, 15-25 Juillet 2007 p.49
laiguillage multiple: bloc SELECT
Selection dune squence dinstruction parmi N
squences possibles
nom: SELECT CASE (crit`ere)
CASE(choix1)
Instructions
CASE(choix2)
Instructions
CASE DEFAULT
Les autres cas
END SELECT nom
SELECT CASE(meth)
CASE(milieu,cen)
call milieu
CASE(trapeze)
call trapeze
CASE DEFAULT
call gauche
END SELECT
Le critre est soit un entier soit une chane de caractre
choix = i1:iN, 2, 9, j1:, :JN
choix = "Lala", "Pz", a:z
Cours a Yaound, 15-25 Juillet 2007 p.50
bloc DO
Rpter une squence dinstructions suivant un compteur
Utilisation :
[nomD :] DO indice= debut, fin, pas
Instructions
END DO [nomD]
Si pas est ngatif le comptage est en sens dcroissant
Exemples
Intg : DO jt =1, Nt, 2
Sum = Sum + aire(jt)
END DO Intg
Boucle innie
DO
i = i+1
IF (i>=10) STOP
END DO
Cours a Yaound, 15-25 Juillet 2007 p.51
Les Boucles : DO WHILE
Faire une squence dinstructions tant que une condition
est ralise
Utilisation :
[nomW :] DO WHILE (test)
Instructions
modification du test
END DO [nomW]
Exemple
cas : DO WHILE (x < 5)
s = s + x
x = x + 1
END DO cas
Cours a Yaound, 15-25 Juillet 2007 p.52
Alternative vectorielle : WHERE
Affectation conditionnelle dans un tableau
WHERE (test)
Instructions
[ ELSEWHERE (test2)
Instructions ]
[ ELSEWHERE
Instructions ]
END WHERE
WHERE( Rho> 0 )
Tab2=1.0/Rho
ELSEWHERE(Pes >0)
Tab2=0.
ELSEWHERE
Tab2=HUGE(1.0)/10
END WHERE
test et test2 sont des tableaux de boolens ayant les
mmes caractristiques.
Cours a Yaound, 15-25 Juillet 2007 p.53
Les Boucles: CYCLE et EXIT
CYCLE [IdBoucle] : il permet dinterrompre litration
en cours et de passer la suivante. Lorsquil y a
plusieurs boucles imbriques, elle permet dinterrompre
litration la boucle tiquete par IdBoucle si cet
argument est spci, sinon la boucle interrompue est
celle dans laquelle on se trouve.
EXIT [IdBoucle] : il permet de sortir de la boucle en
cours, avec les mmes options que prcdemment.
Iter : DO kt=1,KtM
DO i = 1, Ns
X(i) = (i-1)
*
Dx
IF( X(i) > 1000.0 ) EXIT Iter
IF( X(i) > 10.0 ) CYCLE
TAB(i) = X(i)
*
X(i) - 1.0
END DO
END DO Iter
cas : DO
IF (x < 5) EXIT
s = s + x
x = x + 1
END DO cas
Cours a Yaound, 15-25 Juillet 2007 p.54
Maintenabilit
+
Rutilisabilit
=
Modularit
Cours a Yaound, 15-25 Juillet 2007 p.55
Quelques rgles de programmation
Utiliser le format libre
Le COMMON est proscrire, utiliser un module
Ne pas utiliser la dclaration de type implicite. Tous les
programmes, les modules, les subroutines et les
fonctions doivent obligatoirement commencer par la
spcication
IMPLICITE NONE
Cours a Yaound, 15-25 Juillet 2007 p.56
La Bte: Le programme principal
PROGRAM MonProgramme
IMPLICIT NONE
[ specification et declarations ]
!
*****************************************
[instructions executables]
[CONTAINS
procedures internes ]
END PROGRAM Monprogramme
Cours a Yaound, 15-25 Juillet 2007 p.57
Ordre des instructions
PROGRAM, SUBROUTINE, FUNCTION, MODULE
!---------------------------------------
USE
IMPLICIT NONE
!---------------------------------------
declarations
!---------------------------------------
instructions executables
!---------------------------------------
CONTAINS
!---------------------------------------
procedures internes ou procedures modules
!---------------------------------------
END
!---------------------------------------
Cours a Yaound, 15-25 Juillet 2007 p.58
La Procdure
Une procdure dnit une fonction (FUNCTION) ou un
sous-programme (SUBROUTINE). Elle pourra tre:
une unit de programmation F90. Il sagit dune
procdure externe.
construite partir dautres langages que le Fortran.
une composante dune unit de programmation
module. Il sagit dune procdure module.
lintrieur dune procdure module, dune
procdure externe ou dun programme principal. Il
sagit dune procdure interne.
Une unit de programmation contenant une procdure
interne ou une procdure module est appele unit
hte.
Cours a Yaound, 15-25 Juillet 2007 p.59
Lunit de programmation Procdure
Une action Un calcul
SUBROUTINE fft(s,m)
IMPLICIT NONE
[ specifications
et declarations ]
[instructions
executables]
[CONTAINS
procedures
internes ]
END SUBROUTINE fft
FUNCTION fftM(x) RESULT Res
IMPLICIT NONE
[ specifications
et declarations ]
[instructions
executables]
[CONTAINS
procedures
internes ]
END FUNCTION fftM
Cours a Yaound, 15-25 Juillet 2007 p.60
Procdure : Arguments
lattribut INTENT permet de spcier la vocation des arguments dune procdure sauf
si ce sont des pointeurs ou des procdures.
argument dentr : INTENT(IN)
argument de sortie : INTENT(OUT)
argument mixte : INTENT(INOUT)
Lattribut OPTIONAL permet de spcier des arguments dont la prsence nest pas
obligatoire lappel de la procdure.
REAL(KIND=8), OPTIONAL :: X2, X4
La fonction intrinsque PRESENT permet denquter sur la prsence ou non dun
argument optionnel lappel de la procdure.
IF(PRESENT(X4) ) X=2
*
X4
Le passage par mot-cl est fortement conseill sil y a des arguments optionnels, de
plus il permet doublier la position des arguments lors de lappel de la fonction;
Cours a Yaound, 15-25 Juillet 2007 p.61
Procdure : Arguments
les procdures en argument doivent tre dclares avec lattribut EXTERNAL.
Les procdures internes ne peuvent tre passes en argument.
Pour les procdures externes, il est recommand de fournir une interface de
description lunit appelante.
Cest le nom spcique de la procdure qui doit tre fourni mme si elle a un nom
gnrique.
REAL(4), EXTERNAL :: SinPi
EXTERNAL :: SinPiS
La valeur de retour dune fonction doit tre dclar
FUNCTION test (X) FUNCTION test (X) RESULT res
REAL :: test REAL :: res
REAL FUNCTION test (X)
Cours a Yaound, 15-25 Juillet 2007 p.62
Le rle du MODULE
Un module permet de structurer le programme en
fonction de thmatiques: Rsolution de systmes linaires et non
linaires, Solveurs de Riemann, Communications MPI ou PVM, Entrs/Sorties,
Dnitions et donnes partages.
Un Module peut contenir (composantes):
des spcications USE, IMPLICIT NONE
des dclarations dobjets REAL :: Pi = 3.14
des dnitions de types drivs,
des blocs-interfaces (avant le CONTAINS)
un ensemble de procdures (aprs le CONTAINS).
Ces composantes sont empaquetes sous une forme
qui les rend accessibles nimporte o dans le
programme.
Cours a Yaound, 15-25 Juillet 2007 p.63
Cration dun MODULE
MODULE Meth_Relaxation
IMPLICIT NONE
[ specification et declarations
dobjets globaux au module ]
[CONTAINS ! composantes procedures modules
SUBROUTINE GMRESM(A, B, m, X)
[ specification et declarations ]
[instructions executables]
[CONTAINS
procedures internes ]
END SUBROUTINE GMRESM ]
END MODULE Meth_Relaxation
Cours a Yaound, 15-25 Juillet 2007 p.64
Accessibilit dun MODULE
Par dfaut, toutes les ressources dun module sont accessibles.
Il peut tre souhaitable de limiter laccessibilit de ces ressources. Ceci peut se
justier lorsquelles ne sont ncessaires qu lintrieur du module dans lequel elles
sont dnies.
Les ressources non exportables sont dites prives (PRIVATE), les autres sont dites
publiques (PUBLIC).
Les avantages des ressources prives sont :
Aucune corruption accidentelle sur des donnes prives par une procdure
externe au module qui les contient,
des modications de conceptions peuvent tre faites sur les ressources prives
dun module sans affecter le reste du programme,
permet dviter tout type de conits avec les ressources dautres modules...
Cours a Yaound, 15-25 Juillet 2007 p.65
Accessibilit dune composante dun MODULE
La composante dun module peut tre
Publique: cest dire accessible partir des autres composantes du
module et des units de programmation qui utilisent le module.
REAL(8), PUBLIC :: Pi
REAL(4), PUBLIC :: Hbar
PUBLIC :: GMRESM
Prive: cest dire accessible uniquement partir des autres composantes
du module en question.
REAL(8), PRIVATE :: Pi
PRIVATE :: GMRESM
Tous les objets dclars dans un MODULE sont
rmanents (F95) et globaux pour les procdures
modules.
Cours a Yaound, 15-25 Juillet 2007 p.66
Accessibilit des composantes dun MODULE
Par dfaut, toutes les composantes dun module sont
publiques.
Quand la pseudo-instruction PRIVATE apparat toute
seule dans la partie dclaration du module, toutes les
composantes deviennent par dfaut prives.
MODULE Definitions
IMPLICIT NONE
PRIVATE
CONTAINS
END MODULE Definitions
Cours a Yaound, 15-25 Juillet 2007 p.67
Le Module: USE, ONLY, =>
Les composantes publiques dun module sont accessibles depuis une autre unit de
programmation par linstruction USE situe en tte des dclarations et spcications.
USE Definitions
Dans une unit de programmation, on peut restreindre laccs quelques
composantes publiques dun module par linstruction ONLY la suite de USE.
USE Definitions, ONLY : Pi
USE Definitions, ONLY : Pi, SinPi
USE Definitions, ONLY : ! rien dutile
En cas de conit avec un identicateur dans une unit de programmation, on peut
changer localement le nom daccs des composantes publiques dun module par
lutilisation du pointeur => la suite de USE.
USE Definitions, MyPi => Pi ! MyPi est un alias de Pi
USE Definitions, ONLY : MyPi=>Pi, SPi=>SinPi
Cours a Yaound, 15-25 Juillet 2007 p.68
Les interfaces
La abilisation des appels dune procdure
Cours a Yaound, 15-25 Juillet 2007 p.69
Les types dinterfaces
Interface simple ou de description : Permet de dcrire
les arguments dappel dune procdure ainsi que leur
vocation (arguments dentre ou de sortie).
Interface gnrique : Permet de dnir un nom
gnrique pour lappel de plusieurs procdures de
mme nature (subroutine ou function). Le choix
de la procdure execute lors de lappel dpend des
arguments.
Interfaces oprateurs : Permet de dnir de nouvelles
oprations entre des types intrinseques ou non. Elle
permet galement dtendre des oprateurs
intrinsques; on parle alors de surcharge.
Interfaces daffectation : Permet dtendre loprateur
daffection (=) des types non-intrinseques.
Cours a Yaound, 15-25 Juillet 2007 p.70
Interface simple ou de description
INTERFACE
SUBROUTINE Tata(Champs,Surf,SER)
TYPE(LesChamps) , INTENT(IN):: Champs
TYPE(LesSurfaces), INTENT(IN):: Surf
REAL(8) :: SER
END SUBROUTINE Tata
END INTERFACE
Cours a Yaound, 15-25 Juillet 2007 p.71
F90/95 : Interface "explicite" automatique
Les procdures intrinsques;
Les procdures internes;
Les procdures modules;
la procdure appelante accde au module contenant le bloc
dinterface de la procdure appele (USE).
Cours a Yaound, 15-25 Juillet 2007 p.72
F90/95 : Interface "explicite" obligatoire
fonction valeur tableau,
INTERFACE
FUNCTION Tata(Champs) RESULT MonTab
TYPE(LesChamps) , INTENT(IN):: Champs
REAL(8), DIMENSION(12) :: MonTab
END FUNCTION Tata
END INTERFACE
fonction valeur pointeur,
fonction valeur chane de caractres dont la longueur
est dtermine dynamiquement,
INTERFACE
SUBROUTINE Tata(car1,car2)
CHARACTER(
*
), INTENT(IN) :: car1
CHARACTER(
*
), INTENT(OUT) :: car2
END SUBROUTINE Tata
END INTERFACE
Cours a Yaound, 15-25 Juillet 2007 p.73
F90/95 : Interface "explicite" obligatoire
tableau prol implicite,
INTERFACE
SUBROUTINE Tata(MonTab)
REAL, DIMENSION(:,:) :: MonTab
END SUBROUTINE Tata
END INTERFACE
argument formel avec lattribut pointer ou target,
passage darguments mots-cl,
argument optionnel,
INTERFACE
SUBROUTINE Tata(MonTab, X)
REAL, DIMENSION(:,:) :: MonTab
REAL, OPTIONAL :: X
END SUBROUTINE Tata
END INTERFACE
Cours a Yaound, 15-25 Juillet 2007 p.74
Mots-cl : un exemple
INTERFACE
SUBROUTINE test(X1,X2,X3,X4)
REAL(KIND=8), INTENT(IN), OPTIONAL :: X2, X3,X4
REAL(KIND=8), INTENT(INOUT) :: X1
END SUBROUTINE test
END INTERFACE
Les diffrent appels
call test(a,b,c,d) ! tous les arguments sont presents
call test(a) ! pas darguments optionnels
call test(a,X4=d) ! X2,X3 sont absents
call test(a,b,X4=d) ! X3 est absent
call test(a,X2=b,X4=d) ! la forme `a utiliser
call test(X4=d,X1=a,X2=b,X3=c) ! passage par mot cle
Cours a Yaound, 15-25 Juillet 2007 p.75
F90/95 : Interface "explicite" obligatoire
procdure gnrique,
surcharge ou dnition dun oprateur,
surcharge de loprateur daffectation.
Cours a Yaound, 15-25 Juillet 2007 p.76
Interfaces gnriques
LInterface gnrique donne le cadre pour invoquer une famille de procdures distinctes au
moyen dun mme nom: nom gnrique. Le choix de la procdure excuter est
dtermin en fonction du nombre et du type des arguments.
INTERFACE MySend
SUBROUTINE Tata(Champs,Surf,SER)
TYPE(LesChamps) , INTENT(IN):: Champs
TYPE(LesSurfaces), INTENT(IN):: Surf
REAL(8) :: SER
END SUBROUTINE Tata
SUBROUTINE TataN(Champs,Surf,SER)
TYPE(LesChamps) , INTENT(IN):: Champs
TYPE(LesSurfaces), INTENT(IN):: Surf
REAL(4) :: SER
END SUBROUTINE TataN
END INTERFACE
Cours a Yaound, 15-25 Juillet 2007 p.77
Interfaces gnriques
INTERFACE MySend
SUBROUTINE Titi_1(Champs,Surf,SER)
TYPE(LesChamps) , INTENT(IN):: Champs
TYPE(LesSurfaces), INTENT(IN):: Surf
REAL(8) :: SER
END SUBROUTINE Titi_1
SUBROUTINE Titi_2(Champs,SER,RES,N)
TYPE(LesChamps) , INTENT(IN):: Champs
REAL(4) :: SER, RES
INTEGER :: N
END SUBROUTINE Titi_2
SUBROUTINE Titi_3(Champs,Surf)
TYPE(LesChamps) , INTENT(IN):: Champs
TYPE(LesSurfaces), DIMENSION(4), INTENT(IN):: Surf
END SUBROUTINE Titi_3
END INTERFACE
Cours a Yaound, 15-25 Juillet 2007 p.78
Interfaces : Nouveaux oprateurs
Pour dnir un nouvel oprateur, on utilise linterface
operator.
INTERFACE OPERATOR( .op. )
MODULE PROCEDURE ComplxMult
END INTERFACE
.op. est un nouvel oprateur et ComplxMult est la
(ou les) fonction dnissant loprateur.
Lappel de ce nouvel oprateur ce fait de la faon
suivante :
A = B .op. C
Cours a Yaound, 15-25 Juillet 2007 p.79
Interfaces : Surcharge doprateurs
La surcharge doprateurs intrinsques du langage permet dlargir leur champ
dapplication. A condition de respecter la nature (binaire ou unaire) et les rgles de
priorit dnies par le langage. On emploie des procdures de type fonction pour
surcharger un oprateur lexception de loprateur daffectation qui construit une
expression ne retournant aucune valeur. Dans ce cas, cest une procdure de type
subroutine qui sera utilise.
Pour surcharger un oprateur (autre que loprateur daffectation), on utilise linterface
operator.
INTERFACE OPERATOR( op )
MODULE PROCEDURE ComplxMult
END INTERFACE
op est loprateur intrinsque que lon dsire surcharger et ComplxMult est la (ou les)
fonction dnissant la surcharge.
Cours a Yaound, 15-25 Juillet 2007 p.80
Interfaces : Surcharge doprateur
En gnral, on dnira la surcharge doprateur dans un
module.
Lors de la surcharge dun oprateur autre que loprateur
daffectation, le ou les arguments de la fonction associe
doivent avoir lattribut intent(in).
MODULE MesTypes
IMPLICIT NONE
TYPE MyComplex
REAL :: Preel, PImag
END TYPE MyComplex
END MODULE MesTypes
MODULE NewOp
USE MesTypes
!
INTERFACE OPERATOR(
*
)
MODULE PROCEDURE ComplxMult
END INTERFACE
INTERFACE OPERATOR(/)
MODULE PROCEDURE ComplxDiv
END INTERFACE
.......
Cours a Yaound, 15-25 Juillet 2007 p.81
F90/95 : Surcharge doprateur
CONTAINS
FUNCTION ComplxMult(C1, C2)
TYPE(MyComplex), INTENT(in) :: C1, C2
TYPE(MyComplex) :: ComplxMult
!
ComplxMult%Preel = C1%Preel
*
C2%Preel - C1%Pimag
*
C2%Pimag
ComplxMult%Pimag = C1%Preel
*
C2%Pimag + C1%Pimag
*
C2%Preel
END FUNCTION ComplxMult
FUNCTION ComplxDiv(C1, C2)
TYPE(MyComplex), INTENT(in) :: C1, C2
TYPE(MyComplex) :: ComplxDiv
!
ComplxDiv%Preel = C1%Preel
*
C2%Preel + C1%Pimag
*
C2%Pimag
ComplxDiv%Pimag = C1%Preel
*
C2%Pimag - C1%Pimag
*
C2%Preel
END FUNCTION ComplxDiv
END MODULE NewOp
Cours a Yaound, 15-25 Juillet 2007 p.82
F90/95 : Surcharge doprateur
PROGRAM Test
USE NewOp
TYPE(MyComplex) :: A1, A2
A1=MyComplex(2,1) ; A2=MyComplex(3,4)
print
*
, " A1= ", A1 ; print
*
, " A2= ", A2
print
*
, " A1
*
A2= ", A1
*
A2
print
*
, " A1/A2= ", A1/A2
END PROGRAM Test
Cours a Yaound, 15-25 Juillet 2007 p.83
F90/95 : Surcharge doprateur ASSIGNMENT
Pour surcharger loprateur assignment (=), on utilisera un
bloc interface du type interface assignment.
La dnition de loprateur "=" se fera dans un module. Le
sous-programme qui dnit lassignation pourra tre un
sous-programme externe ou interne au module. On
prfrera cette dernire mthode.
Lors de la surcharge de loprateur daffectation, le 1er ar-
gument doit avoir l attribut intent(out) ou intent(inout) et le
2eme lattribut intent(in).
Cours a Yaound, 15-25 Juillet 2007 p.84
F90/95 : Surcharge doprateur ASSIGNMENT
Exemple
MODULE Assign
INTERFACE ASSIGNMENT(=)
MODULE PROCEDURE Char2Int
END INTERFACE
CONTAINS
SUBROUTINE Char2Int(n,c)
INTEGER, INTENT(OUT) ::n
CHARACTER(
*
), INTENT(IN) ::c
........
END SUBROUTINE
END MODULE
Cours a Yaound, 15-25 Juillet 2007 p.85
Visibilit
Cours a Yaound, 15-25 Juillet 2007 p.86
Visibilit
Les attributs PUBLIC et PRIVATE ne peuvent apparatre qu lintrieur dun module.
Linstruction PUBLIC ou PRIVATE sans argument ne peut apparatre quune seule fois
dans un module,
Si une procdure a un identicateur gnrique, laccessibilit son nom spcique est
indpendante de laccessibilit son nom gnrique,
Une entit dont le type a t dni avec lattribut PRIVATE ne peut pas possder
lattribut PUBLIC,
si une procdure a un argument formel ou un rsultat avec un attribut PRIVATE, la
procdure doit tre munie de lattribut PRIVATE.
Cours a Yaound, 15-25 Juillet 2007 p.87
F90/95 : Visibilit
Variables et objets publiques ou privs:
REAL , PUBLIC :: Coor
INTEGER , PRIVATE :: VigieName
TYPE(MyComplex), PRIVATE :: C1, C2
Modication du mode par dfaut
MODULE Tata ; PRIVATE
liste dobjets de variables ou de procdures non
affects par le mode par dfaut:
PRIVATE ComplxMult, RCMult1, RCMult2
PUBLIC ComplxDiv, ComplxEq
Cours a Yaound, 15-25 Juillet 2007 p.88
Visibilit dun type driv
Les attributs PUBLIC et PRIVATE peuvent sappliquer aux
types drivs.
Un type driv peut tre:
public ainsi que ses composantes: type driv
transparent,
priv,
public mais avec toutes ses composantes prives: type
driv semi-priv.
Par dfaut les composantes dun type driv public sont
publiques.
Cours a Yaound, 15-25 Juillet 2007 p.89
Visibilit dun type driv
Lutilisation dun type driv semi-priv prsente lavantage
de permettre des changements sur le type sans affecter de
quelque manire que ce soit les units utilisatrices.
Reprenons lexemple du type "privatecomplex". On
transforme le type public en type semi-priv.
type private_complex
private
real :: reel, im
end type private_complex
Les composantes de ce type tant prives, il est ncessaire
de fournir dans le module qui le dnit des fonctions qui per-
mettent dy accder ou de les modier.
Cours a Yaound, 15-25 Juillet 2007 p.90
F90/95 : Visibilit
Lors de lutilisation dun module, il se peut que dans lunit
utilisatrice, il existe des ressources ayant le mme nom.
Dans ce cas,il est possible de renommer les ressources du
module dans lunit qui y accde via loprateur "" au
niveau de linstruction
USE NewOp, NewName => ComplxMultP
Lorsque seulement un sous-ensemble des noms dnis
dans un module est requis, loption ONLY est disponible,
avec la syntaxe suivante:
USE NewOp, ONLY: NewName => ComplxMultP
Cours a Yaound, 15-25 Juillet 2007 p.91
Vers le Fortran 95/2000/2003
Cours a Yaound, 15-25 Juillet 2007 p.92
Squences parallles : FORALL
Contrler lexcution dinstructions (affectation, association,
...) an de faciliter leurs distributions sur les processeurs
! Utilisation
[nom:] FORALL ( indices, indices [, filtre] )
Instructions
END FORALL [nom]
!Exemple
FORALL( i = 1:100:5, j = 1:10 , i > j)
Tab2(i) = i
Tab2(j) = j
END FORALL
Cours a Yaound, 15-25 Juillet 2007 p.93
Procdure sans effet de bord : PURE
Une fonction avec lattribut PURE est une fonction sans effet de bord
! Utilisation
PURE FUNCTION ThePure( les, arguments )
END FUNCTION ThePure
Ses paramtres autres que les pointeurs et les procdures doivent avoir lattribut
INTENT(IN).
Lattribut SAVE est interdit, on ne doit pas modier une variable globale.
Pas dordre STOP ni des I/O dans les instructions.
on peut appeler la fonction dans une boucle FORALL.
Cours a Yaound, 15-25 Juillet 2007 p.94
Procdure distributive : ELEMENTAL
Une fonction (ou procdure) distributive est une fonction pure qui nadmet que des
paramtres scalaires, autres que les pointeurs.
Le rsultat doit tre un scalaire.
! Utilisation
ELEMENTAL SUBROUTINE PERMUT(X,Y)
REAL(8), intent(inout) :: X,Y;
REAL :: Temp
Temp = X ; X = Y ; Y = Temp
END SUBROUTINE PERMUT
Cours a Yaound, 15-25 Juillet 2007 p.95
F90/95 : Caractristiques obsoltes
On dsigne par caractristiques obsoltes, les caractristiques qui sont susceptibles dtre
limines lors dune prochaine phase de normalisation. Ce sont des caractristiques
redondantes et pour lesquelles une meilleure mthode peut tre utilise.
IF arithmtique.
Branchement sur une instruction END IF depuis lextrieur du bloc IF - END IF.
Variation de la syntaxe dune boucle DO * Partage dune mme instruction par
plusieurs boucles DO. * Fin de boucle DO autres que CONTINUE ou END DO. *
Variables dindice et instructions de contrle rels simple ou double prcision.
Instruction ASSIGN et linstruction GOTO assign.
GO TO calcul remplac par une construction CASE,
ASSIGN dune tiquette de FORMAT.
Cours a Yaound, 15-25 Juillet 2007 p.96
F90/95 : Caractristiques obsoltes
linstruction RETURN secondaire remplac par une construction CASE,
Instruction PAUSE.
linstruction DATA place au sein des instructions excutables,
Descripteur ddition H.
le type character(len=
*
) de longueur implicite en retour de fonction,
le type character
*
dans les dclarations.
fonction instruction remplac par les fonctions internes,
Cours a Yaound, 15-25 Juillet 2007 p.97
F90/95 :volution vers la norme Fortran95
Le processus de normalisation se poursuit mais les apports de la norme Fortran95 sont
mineurs. Des extensions sont proposs pour une adaptation aux machines parallles
distribues.
Instruction et construction FORALL,
les attributs PURE et ELEMENTAL pour les procdures sans effet de bord,
la fonction intrinsque NULL() pour forcer un pointeur ltat non associ,
fonction utilisateur dans les expressions de spcication,
extension de la construction WHERE : blocs imbriqus,
fonction intrinsque CPU_TIME,
libration des tableaux dynamiques locaux nayant pas lattribut SAVE,
initialisation par dfaut pour les objets de type driv,
extension des fonctions intrinsques CEILING, FLOOR,MAXLOC, MINLOC,
Commentaire dans les spcications de NAMELIST,
modications pour sadapter IEEE 754/854.
Cours a Yaound, 15-25 Juillet 2007 p.98
Quelques rgles de codage
Il est recommander dadopter une charte pour uniformiser
les dveloppements
Mots cls fortran, fonctions intrinsques, types
utilisateurs, doivent tre en majuscule.
Le nom des variables premire lettre en majuscule puis
les autres en minuscule
Pensez indenter le corps des units de programmes,
des blocs de contrles, les blocs interface, ...
Commenter vos codes : description en entte des
procedures, et dans le code laide de !
Cours a Yaound, 15-25 Juillet 2007 p.99
Fortran 2003
Intgration dans le systme GET_ARG
Interoprabilit avec le C.
polymorphisme (des variables, des pointeurs et des
procdures) CLASS, SELECT TYPE,
lHritage (type drivs, procdures)
Surcharge de procdures
Cours a Yaound, 15-25 Juillet 2007 p.100
Bibliographie
C. Delannoy, Programmer en Fortran 90, Eyrolles, 1998.
P. Lignelet, Manuel complet du langage Fortran 90 et Fortran 95, Calcul intensif et
gnie logiciel, Masson, 1996.
M. Metcalf and J. Reid, fortran 90/95 explained, Oxford sciences publications, 1996.
P. Corde et H. Delouis Cours Fortran 90/95 de lIdris (2me niveau)
http://webserv2.idris.fr/data/cours/lang/fortran/choix_doc.html
M. Dubesset et J. Vignes, les spcicits du fortran 90, Editions technip, 1993.
Cours a Yaound, 15-25 Juillet 2007 p.101
Prcision
Fichier precision1.f90 : Ce programme permet de tester des oprations sur et entre
diffrents types ainsi que la conversion dun rel en un entier. Il permet galement
dobserver les diffrences entre kind=4 et kind=8 ansi que les affectations dans ces
deux types :
x=0.9 (simple prcision)
x=9.0d-1 (double prcision)
Des perturbations numriques apparaissent ds quun rel simple prcision est
affecte dans une variable double prcision. En rsum, les sous-types dnis par
kind ne doivent pas tre ngligs.
Fichier precision2.f90 : Programme de test de test de la prcision machine prsent
dans le cours
Cours a Yaound, 15-25 Juillet 2007 p.102
Fichier where.f90 : Ce programme prsente diffrentes techniques dinitialisations et
daccs un tableau. En particulier, il prsente une utilisation des vecteurs anonymes
et des pseudo-boucles. Une utilisation de la fonction intrinsque where est propose.
Lexemple que nous considrons ici est de calculer la racine carre des lments dun
tableau sils sont positifs avec un cutt-off zro pour les lments ngatifs.
Cours a Yaound, 15-25 Juillet 2007 p.103
Fichiers main.f90 lect.f90 integ.f90 fonc.f90 : Ce programme est un exemple de procdure
passe en argument dune fonction. Le programme lit une liste de point, X, contenu
dans le chier LISTE. Cette procdure de lecture appartient au module lect. On
propose ensuite dintegrer une fonction sur lintervalle [MINVAL(X),MAXVAL(X)].
Cette fonction intgrer est donne dans le module fonc et sappelle func avec un
argument m permettant de choisir une fonction parmis plusieurs. fonc est pass en
argument de la fonction integ. Les autres arguments de integ sont X (pour les
bornes de lintervalle dintgration), m (pour le choix de la fonction intgrer) et meth
(pour le choix de la mthode dintgration). Il est important de noter la prsence de
linterface (obligatoire) de description de la fonction passe en argument dans la
fonction integ.
Cours a Yaound, 15-25 Juillet 2007 p.104
Fichiers frac mod.f90 surcharge.f90 : Ce programme prsente un exemple de cration de
deux nouveaux oprateurs .plus. et .mult. dnis dans le module op_objet. Ces
oprateur permettent laddition et la multiplication entre deux variables dont le type est
dni par deux champs. Ce type permet de reprsenter les fractions.
Fichiers frac mod.f90 comp mod.f90 surcharge.f90 : Ce programme est identique au
prcdent mais cette fois, le type est abstrait. Les champs qui le composent ne sont
accessibles que dans le module op_objet. Nous avons donc ajout dans le module
des procdures permettant dinitialiser de nouvelles variables et de les afcher
lcran. Le chier comp mod.f90 est identique frac mod.f90 mais pour des nombres
complexes. Cela permet avec le mme programme principal de traiter des fractions ou
des nombres complexes suivants les besoins de lutilisateur.
Fichiers frac mod.f90 comp mod.f90 surcharge.f90 : Ce programme est identique au
prcdent mais avec une surcharge des oprateurs + et *.
Cours a Yaound, 15-25 Juillet 2007 p.105
Rsolution Numrique dune LdC 1D.
La forme continue du problme: uuu(x, t)

t
uuu+
x
(f(uuu)) = 0, uuu(x, 0) = uuu
0
(x), uuu(x+L, t) = uuu(x, t)
Maillage structur: t
n
= nt, x
j
= jx, n = 0, Nmax et
j = 1, Ns
x
1
= x, x
Ns
= L, x =
L
Ns
La solution approche est dnie par:
vvv(x, t) = vvv
n
i
(x, t) ]x
i
1
2
, x
i+
1
2
[[t
n
, t
n+1
[,
vvv
0
i
=
1
x
_
x
i+
1
2
x
i
1
2
uuu
0
(x)dx
Cours a Yaound, 15-25 Juillet 2007 p.106
Schma et Flux Numriques.
Schma conservatif:
vvv
n+1
i
= vvv
n
i

t
x
_

i+
1
2

i
1
2
_
Flux de Lax-Friedrichs :

i+
1
2
=
LF
(vvv
n
i
, vvv
n
i+1
) =
1
2
_
f
n
i+1
+ f
n
i
+
x
t
_
vvv
n
i
vvv
n
i+1
_
_
Flux de Murman-Roe :

i+
1
2
=
MR
(vvv
i
, vvv
i+1
) =
1
2
_
f
n
i+1
+ f
n
i
+

f
n
i+
1
2
vvv
n
i+
1
2

_
vvv
n
i+1
vvv
n
i
_
_
avec X
n
i+
1
2
= X
n
i+1
X
n
i
Cours a Yaound, 15-25 Juillet 2007 p.107
Schma et Flux Numriques.
Flux de Lax-Wendroff :

LW
(vvv
i
, vvv
i+1
) =
1
2
_
f
n
i+1
+ f
n
i

xf
n
i+
1
2
tvvv
n
i+
1
2
_
f
n
i+1
f
n
i
_
_
Condition de stabilit approche:
max

t
x
f
0
i+
1
2
vvv
0
i+
1
2

= CFL <
1
2
=t =
xCFL
max

f
0
i+
1
2
vvv
0
i+
1
2

Cours a Yaound, 15-25 Juillet 2007 p.108

Algorithme.
f(vvv) et uuu
0
(x) des fonctions donnes.
L, Ns, CFL, T paramtres donns, Tl = 0.
Initialisations : x =
L
Ns
, x
j
= jx pour j = 1, Ns.
Initialisations : vvv
0
i
uuu
0
(ix) et f
0
i
f(vvv
0
i
) pour i = 1, Ns.
Initialisations : t =
xCFL
max

f
0
i+
1
2
vvv
0
i+
1
2

,
Nmax INTEGER(T/t).
Boucle en temps
vvv
n+1
i
= vvv
n
i

t
x
_

i+
1
2

i
1
2
_
Cours a Yaound, 15-25 Juillet 2007 p.109
Boucle en temps.
Boucle en temps: Pour n = 0, Nmax + 1
Calculer les ux
i+
1
2
pour i = 1, Ns 1.
Conditions aux limites priodiques:
1
2
=
Ns+
1
2
= (vvv
n
Ns
, vvv
n
1
).
Evolution en temps: vvv
n+1
i
= vvv
n
i

t
x
_

i+
1
2

i
1
2
_
.
Tl = Tl + t, si T Tl < t alors t = T Tl
Cours a Yaound, 15-25 Juillet 2007 p.110
Mise en uvre En fortran 90.
Paramtre Caractristiques en F90
Type Rang Dim Variable
i INTEGER 1 1 i
j INTEGER 1 1 j
Ns INTEGER 1 1 Ns
n INTEGER 1 1 n
nmax INTEGER 1 1 Nmax
L REAL 1 1 L
T REAL 1 1 T
Tl REAL 1 1 Tl
CFL REAL 1 1 CFL
Cours a Yaound, 15-25 Juillet 2007 p.111
Mise en uvre En fortran 90.
Paramtre Caractristiques en F90
Type Rang Dim Nom
x REAL 1 1 Dx
t REAL 1 1 Dt
x
j
REAL 1 Ns Xp

j+
1
2
REAL 1 0:Ns FluxN
uuu
n
j
REAL 1 1:Ns Rho
uuu
n+1
j
REAL 1 1:Ns RhoNew
Cours a Yaound, 15-25 Juillet 2007 p.112
Mise en uvre En fortran 90.
Paramtre Caractristiques en F90
Type Rang Dim Nom
max

f
0
i+
1
2
vvv
0
i+
1
2

REAL 1 1 Cmax
uuu
0
(x) REAL FUNCTION 1 1 RhoInit
f REAL FUNCTION 1 1 Flux

LF
(vvv
i
, vvv
j
) REAL FUNCTION 1 1 FluxLF

LW
(vvv
i
, vvv
j
) REAL FUNCTION 1 1 FluxLW

MR
(vvv
i
, vvv
j
) REAL FUNCTION 1 1 FluxMR
Cours a Yaound, 15-25 Juillet 2007 p.113
Structuration du logiciel en fortran 90.
Organisation:
Un module LesFonctions de fonctions (rutilisable
dans dautres contextes) contenant les fonctions .
Un programme principal LdcNonLineaire avec un
mot cl (RootName) donn lexcution du programme.
Lectures des donnes dans un chier format :
(RootName).data.
Sauvegardes dans des chiers de la forme
(RootName)_(n).xmgr.
o n est le numro de litration laquelle la
sauvegarde a lieu.
Cours a Yaound, 15-25 Juillet 2007 p.114
Fonctions Intrinques Utililes.
TRIM : Construit une nouvelle chane de caractre en
Supprimant les blancs la n dune autre chane de
caractre. NewName = TRIM(OldName)
AJUSTL : Supprime les blancs au dbut dune chane
de caractre. NewName = AJUSTL(OldName)
LEN_TRIM : Donne la taille dune chane de caractre,
ne tenant pas en compte des blancs la n.
il=LEN_TRIM(OldName)
WRITE : utilis ici pour transformer un entier en chane
de caractre. WRITE(OldName,
*
) n
Cours a Yaound, 15-25 Juillet 2007 p.115
Procdure de construction de Nom de chier.
La premire procdure TheNewName que nous dcrivons
est celle qui construit un nom de chier NewName partir
dune chane de caractre RootName et dun nombre entier
n reprsent sur Nm caractres et complt au besoin par
des zros au dbut.
Cours a Yaound, 15-25 Juillet 2007 p.116
Procdure TheNewName.
SUBROUTINE TheNewName(Name, n, Nm, NewName)
CHARACTER(LEN=
*
), INTENT(IN) :: Name
INTEGER , INTENT(IN) :: n, Nm
CHARACTER(LEN=
*
), INTENT(OUT) :: NewName
INTEGER :: l , m
CHARACTER(LEN=20) :: NB, Ze
Ze ="000000000000000"; WRITE(NB,
*
) n
NB = ADJUSTL(NB); l= LEN_TRIM(NB) ; m=Nm-l
IF( l > 0 ) THEN
NewName=TRIM(Name)//"_"//Ze(1:m)//TRIM(NB)
ELSE
NewName=TRIM(Name)//"_"//TRIM(NB)
END IF
END SUBROUTINE TheNewName
p
Cours a Yaound, 15-25 Juillet 2007 p.117
Fonction Flux de Roe.
REAL FUCTION RoeFlux(Vi, Vj, Flux)
REAL , INTENT(IN) :: Vi, Vj
REAL , EXTERNAL :: Flux
END SUBROUTINE TheNewName
Cours a Yaound, 15-25 Juillet 2007 p.118
Dclarations En fortran 90.
INTEGER :: Ns, Nmax, n, i, j
REAL :: L, Dx, Dt, T, Tl, Cmax, CFL
REAL, DIMENSION(:), ALLOCATABLE :: Rho, RhoNew
REAL, DIMENSION(:), ALLOCATABLE :: Xp, FluxN
Cours a Yaound, 15-25 Juillet 2007 p.119
Mise en uvre En fortran 90.
Sauvegarde de la solution au temps nal:
Open(10,FILE=Final.xmgr)
DO i = 1, Ns
WRITE(10, (1x,2(EN15.8,1x) )) X(i), V(i)
END DO
CLOSE(10)
Cours a Yaound, 15-25 Juillet 2007 p.120
Ensemble des chiers utiliss pour
les travaux pratiques.
Cours a Yaound, 15-25 Juillet 2007 p.121
Travaux Pratiques
Familiarisation aux subtilits du
Fortran 90/95.
Cours a Yaound, 15-25 Juillet 2007 p.122
Cours a Yaound, 15-25 Juillet 2007 p.123
Travaux Pratiques
Utilisation des diffrents types
dInterfaces
Cours a Yaound, 15-25 Juillet 2007 p.124
Cours a Yaound, 15-25 Juillet 2007 p.125
Travaux Pratiques
Exemples de mise en uvre de la
modularit.
Cours a Yaound, 15-25 Juillet 2007 p.126
Cours a Yaound, 15-25 Juillet 2007 p.127
Travaux Pratiques
Performances en fonction de la
stratgie de programmation
Cours a Yaound, 15-25 Juillet 2007 p.128
Cours a Yaound, 15-25 Juillet 2007 p.129
Travaux Pratiques
Exemples divers.
Cours a Yaound, 15-25 Juillet 2007 p.130
Cours a Yaound, 15-25 Juillet 2007 p.131