Modules, interfaces et genericité

Les interfaces

Les interfaces jouent un r^ole tres important et quasi systematique en Fortran 90. Elles permettent de de nir les prototypes des fonctions et subroutines de nies de maniere externe. Dans ce r^ole, elles sont les analogues des inclusions de chiers de header en C.
function t o t o ( a , b )
implicit none
real , intent ( in ) : : a , b
real : : t o t o
end function t o t o
program t e s t
implicit none. . .
interface
function t o t o ( a , b )
real , intent ( in ) : : a , b
real : : t o t o
end function t o t o
end interface. . .
end program t e s t
Les interfaces permettent egalement de surcharger des methodes pour plusieurs types d’arguments.
Le bloc interface associe sera de la forme :
interface t o t o
subroutine t o t o i n t ( n )
integer , intent ( in ) : : n
end subroutine t o t o i n t
subroutine t o t o r e a l ( r )
i r e a l , intent ( in ) : : r
end subroutine t o t o r e a l
end interface
3.2.2 Les modules
Il s’agit d’un autre point fort de Fortran 90, a savoir la possibilite de programmer des modules, c’est-a-dire des librairies particulieres dont on peut choisir d’utiliser tout ou partie.
module mon module
type t o t o
. . .
end type t o t o
interface operator ( . t i t i . ) ! s u r c h a r g e d ’ o p e r a t e u r
module p r o c e d u r e t a t a
end interface
contains
subroutine t a t a ( a , b )
. . .
end subroutine t a t a
function t u t u ( a , b )
. . .
end function t u t u
end module mon module
program t e s t
use mon module , only : t u t u ! chargement de l a f o n c t i o n t u t u du module
implicit none
. . .
end program
Quelques remarques :
{ Dans cet exemple, on montre l’utilisation de ONLY. Si l’on veut charger tout un module, on ecrira USE mon module.
{ Le chargement d’un ou plusieurs modules se fait en tout debut de programme, avant la commande IMPLICIT NONE et les declarations et initialisations de variables.
{ Cet exemple montre egalement la notion de surcharge (ou surde nition) d’operateur. Possibilite est donnee non seulement de surcharger les operateurs existants (+, -, *, /, .and., <, . . . ) a condition que ce soit pour des types di erents que ceux pour lesquels ces operateurs sont deja de nis, mais aussi de de nir de nouveaux operateurs dont le nom sera de la forme .NOM. .

Complements sur les tableaux

Manipuler des tableaux

Sections de tableaux

Encore un point fort de Fortran , la possibilite de manipuler des sections de tableaux avec des syntaxes de la forme a(debut: n :pas). Si le pas est omis, il a la valeur 1 par defaut.

initialisation / a ectation

L’exemple ci-dessous montre les deux manieres standard d’initialiser un tableau, la maniere globale et la maniere elementaire :
real , dimension ( 5 ) : : a , b
a=(/ 2 . , 3.2 , 1.0, 5.9 , 4.5 /) # i n i t i a l i s a t i o n g l o b a l e
b=(/ ( 2 i +1, i =1 ,5) / ) # i n i t i a l i s a t i o n g l o b a l e
a ( 2 ) = 1.5 # i n i t i a l i s a t i o n d ’ un e l e m e n t
La « maniere »globale » ne fonctionne que pour des tableaux de rang 1. Pour des tableaux multidimen-sionnels, on est donc amen a utiliser la maniere elementaire ou d’utiliser un tableau temporaire de rang 1 que l’on redimensionnera a l’aide de la fonction reshape

Operateurs elementaires

Tout operateur de ni sur des types donnes fonctionnent avec des tableaux de m^emes types. Ces operateurs fonctionneront alors element a element, a la condition que les tableaux impliques soient de m^eme pro ls pour les operateurs binaires (+, -, *, /, . . . ).
Une consequence pratique est la possibilite d’a ecter une valeur a chacun des elements d’un tableau avec l’instruction a=0..
Il existe par ailleurs un certain nombre de fonctions elementaires :
{ sum(t1), product(t1) ! calcule la somme (le produit) de tous les elements de t1 { size(t1,i) ! donne l’etendue du tableau t2 selon la dimension i
{ maxval(t1), minval(t1) ! fournit la plus grande (petite) valeur de t1
{ dot product(t1,t2) ! calcule le produit scalaire de deux tableaux de rang 1 et de m^eme taille t1 et t2, qui peuvent ^etre des tableaux de reels, d’entiers, de complexes et m^eme de booleens.
{ matmul(A,B) ! calcule le produit A*B de deux tableaux de rang 2 et dont les dimensions sont compatibles.

L’instruction WHERE

C’est la generalisation du IF pour des tableaux, dans le sens ou on va e ectuer une operation lo-gique sur un tableau et suivant le resultat element par element, e ectuer une a ectation speci que. L’exemple suivant montre comment recuperer la partie positive d’un tableau, c’est-a-dire e ectuer l’ope-ration b=max(a,0) :
where( a >0.)
b=a
else where
b=0.
end where
On pourrait dans l’exemple precedent ecrire :
b=0.
where( a >0.)
b=a
end where
ou
b=0.
where( a >0.) b=a

Passage en arguments – pro ls implicites et automatiques

J’ai inclus ici les cha^nes de caracteres qui se comportent quelque peu comme des tableaux de carac-teres.
Lorsqu’on declare un argument d’entree d’une fonction ou d’une procedure, on peut souhaiter ne pas de nir explicitement le pro l d’un tableau. Fortran 90 autorise la de nition implicite. Pour les tableaux en argument de sortie, on parlera de pro l automatique.
function f c t ( a , b )
real , dimension ( : , : ) , intent ( in ) : : a
character ( len= ) , intent ( in ) : : b
real , dimension ( s i z e ( a , 1 ) , s i z e ( a , 2 ) ) : : f c t
. . .
end function f c t

Tableaux dynamiques – attribut ALLOCATABLE ou POINTER

Une autre possibilite est de declarer un tableau et d’allouer dynamiquement la memmoire au moment ou on en a besoin. Dans ce cas, on declare un tableau de pro l implicite avec l’attribut ALLOCATABLE.
program t o t o
implicit none
real , dimension ( : , : ) , allocatable : : tab
. . .
allocate ( tab ( 1 0 , 2 0 ) )
. . .
deallocate ( tab )
end program t o t o
Une remarque importante, la desallocation d’un tableau dynamique doit se faire dans le m^eme bloc programme (un programme, une fonction, ou une procedure) que la declaration et l’allocation. Cela a pour consequence fondamentale que l’on ne peut declarer un tableau dynamique comme argument de sortie d’une fonction ou d’une procedure, du moins de maniere rigoureuse, car certains compilateurs l’autorisent.
La solution a adopter est d’utiliser un pointeur de tableau. Comme annonce plus haut dans le para-graphe concernant les pointeurs, on peut se passer d’une cible et d’allouer la memoire avec la fonction ALLOCATE, comme on le ferait en C avec la fonction malloc.
program t o t o
implicit none
real , dimension ( : , : ) , pointer : : tab
. . .
allocate ( tab ( 1 0 , 2 0 ) )
. . .
deallocate ( tab )
end program t o t o
Dans ce cas, on peut passer un tableau « dynamique » en argument de sortie.

Les formats

Les di erents formats

An represente n caracteres.
In represente un entier sur n caracteres.
Fn.p represente un reel en notation ottante avec n caracteres dont p decimales. La virgule compte pour un caractere.
En.p represente un reel en notation exponentielle avec n caracteres au total dont p decimales dans la mantisse.
nX represente n espaces.
Ln represente un booleen sur n caracteres.
Tn represente un positionnement au n-ieme caractere.
/ represente un passage a la ligne.
* represente un format libre.

Formats et entrees / sorties standard

L’exemple suivant montre la syntaxe des entrees / sorties standard, avec di erents formats, y compris par le biais d’etiquette et de la fonction format

La gestion des entrees / sorties

Entrees / sorties sequentielles

Les entrees / sorties sequentielles representent l’utilisation des chiers la plus courante et la plus elementaire, a savoir le parcours d’un chier ligne apres ligne.
program i o s e q f i l e
implicit none
integer : : a
real : : r
open( unit =12 , form=’formatted ’ , f i l e =’ t o t o . txt ’ )
read ( 1 2 , ) a
close ( 1 2 )
. . .
open( unit =25 , form=’unformatted ’ , f i l e =’ t a t a . txt ’ , &
status=’new ’ )
write ( 2 5 ) r
close ( 2 5 )
end program i o s e q f i l e

OPEN et CLOSE

Les arguments les plus courants des commandes OPEN et CLOSE sont :
unit= (obligatoire en premier argument) la valeur 5 est reservee pour l’entree standard, la valeur 6 est reservee pour la sortie standard. De maniere generale, 1 < unit < 99.
status= permet de speci er s’il s’agit d’un chier existant (’old’), a creer (’new’), a remplacer (’replace’), temporaire (’scratch’) ou de statut quelconque (’unknown’)
form= (open uniquement) permet de speci er si le chier ouvert est binaire (’unformatted’) ou ASCII (’formatted’), c’est a dire lisible par tout editeur de texte.
iostat=val la variable entiere val sera initialisee a une valeur strictement positive en cas d’erreur d’entree / sortie, ou nulle sinon.
err=etiq permet de se positionner a l’etiquette etiq en cas d’erreur de lecture / ecriture.
position= (open uniquement) permet de se positionner dans le chier ouvert, au debut (’rewind’), a la n (’append’), ou a la derniere position en date si chier deja ouvert (’asis’).

1 Types de données et attributs 
1.1 Les types de donnees
1.1.1 Les types INTEGER, REAL et COMPLEX
1.1.2 Le type LOGICAL
1.1.3 Le type CHARACTER
1.1.4 Le type TYPE
1.2 Les attributs
1.2.1 L’attribut PARAMETER
1.2.2 L’attribut DIMENSION
1.2.3 Les attributs POINTER et TARGET
2 Structures de controle et expressions logiques
2.1 IF
2.2 SELECT CASE
2.3 DO et DO WHILE
2.4 Les instructions GOTO et STOP
3 Structure d’un programme 
3.1 Programmes, procedures et fonctions
3.1.1 Le programme
3.1.2 Les procedures ou subroutines
3.1.3 Les fonctions
3.1.4 Les fonctions recursives
3.2 Modules, interfaces et genericite
3.2.1 Les interfaces
3.2.2 Les modules
4 Complements sur les tableaux 
4.1 Manipuler des tableaux
4.1.1 Sections de tableaux
4.1.2 initialisation / aectation
4.1.3 Operateurs elementaires
4.1.4 L’instruction WHERE
4.2 Passage en arguments – prols implicites et automatiques
4.3 Tableaux dynamiques – attribut ALLOCATABLE ou POINTER
5 Les formats 
5.1 Les dierents formats
5.2 Formats et entrees / sorties standard
6 La gestion des entrees / sorties 
6.1 Entrees / sorties sequentielles
6.1.1 OPEN et CLOSE
6.1.2 READ et WRITE
6.2 Entrees / sorties a acces direct
6.3 Entrees / sorties internes