COURS DE FORTRAN 90

Matmeca 1` ere ann ee ENSEIRB-MATMECA

Luc Mieussens
Luc.Mieussens@math.u-bordeaux1.fr - equipe Calcul Scientique et Mod elisation -

Institut de Math ematiques de Bordeaux Universit e de Bordeaux

version du 28 septembre 2011

Le but de ce cours est dapprendre ` a programmer en fortran 90. Il est pr evu pour 8 s eances d1h20, accompagn e de 8 s eances de quatre heures de TD-TP sur machine. Jai essay e de le pr esenter non pas comme une collection exhaustive de commandes (ce qui permet difficilement de pouvoir programmer avant davoir fini le cours) mais plut ot comme une progression en trois phases. La premi` ere partie devrait permettre de pouvoir ecrire vos premiers programmes apr` es une ou deux s eances seulement. La deuxi` eme introduit certains concepts plus complexes (sous-programmes, types d eriv ees, allocation dynamique). Les troisi` eme et quatri` eme parties mettent laccent sur les apports r eellement nouveaux de fortran 90 par rapport au vieux fortran 77 (modules, interfaces g en eriques, surcharge dop erateurs, pointeurs). Nombre de commandes pr esent ees ici sont expliqu ees avec beaucoup plus de pr ecision dans divers cours et manuels de r ef erence donn es dans la bibliographie. Ces r ef erences sont en acc` es libre et gratuit sur internet. Nh esitez pas ` a les consulter d` es que vous en avez besoin. Le langage fortran evolue r eguli` erement, mais la v eritable evolution a et e faite en passant du fortran 77 au fortran 90. Les nouvelles normes fortran 95 (puis fortran 2003, fortran 2008) napportent que des fonctionnalit es nouvelles. Par cons equent, tout ce qui est dit ici devrait rester valable avec les normes futures. Enfin, je veux insister sur le fait que quel que soit le cours que vous utiliserez, il ny en fait quun seul moyen dapprendre ` a programmer : cest de programmer soi-m eme (de la m eme fa con que lon napprend bien une langue etrang` ere quen la parlant soi-m eme). Donc usez et abusez de votre temps en salle machine (le temps des s eances de TP ny suffira pas), cest la garantie du succ` es.

Table des mati` eres

1 Introduction 1.1 1.2 Quest-ce quun programme informatique ? . . . . . . . . . . . . Le langage F90 : g en eralit es . . . . . . . . . . . . . . . . . . . 6 6 9

Premiers pas en F90 2.1 2.2 2.3 2.4 2.5 2.6 2.7 Exemple de programme . . . . . . . . . . . . . . . . . . . . . . structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11 11 11 11 14 15 16 17 17 20 21 24 25 28 29 30

Les variables

les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . Continuation de ligne : caract` ere & . . . . . . . . . . . . . . . . Les commentaires : symbole ! Les structures de contr ole 2.7.1 2.7.2 2.7.3 Le test if . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . case . . . . . . . . . . . . . . . . . .

La s election select

It erations : structure do . . . . . . . . . . . . . . . . . .

2.8 2.9

Les entr ees-sorties ecran/clavier . . . . . . . . . . . . . . . . . Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.10 Ex ecution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11 Ecrire un programme proprement . . . . . . . . . . . . . . . .

2.12 Exemple complet . . . . . . . . . . . . . . . . . . . . . . . . .

Un peu plus loin ... 3.1 3.2 Variables constantes . . . . . . . . . . . . . . . . . . . . . . Sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.2.6 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctionnement . . . . . . . . . . . . . . . . . . . . . . Arguments dune subroutine . . . . . . . . . . . . . . . . . .

32 32 33 33 36 37 38 40 44

Arguments dune fonction - d eclaration du r esultat

Les tableaux en arguments . . . . . . . . . . . . . . . . Les cha nes en arguments . . . . . . . . . . . . . . . . .

3.3

Tableaux 3.3.1 3.3.2 3.3.3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

45 45 45

Tableaux statiques

Allocation dynamique . . . . . . . . . . . . . . . . . . . Allocation dynamique dans un sous-programme : tableaux automatiques . . . . . . . . . Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

46 47 48 49 51

3.3.4 3.3.5 3.3.6 3.3.7 3.3.8 3.4

Op eration conformes entre tableaux

Cr eer des tableaux ` a la main . . . . . . . . . . . . . . Les sections de tableaux . . . . . . . . . . . . . . . . .

Stockage des tableaux dans la m emoire et ordre des boucles 51 54

Entr ees-sorties (E/S) . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 3.4.2

E/S en format libre, dans un fichier texte ` a acc` es s equentiel 54 E/S dans un fichier binaire ` a acc` es s equentiel . . . . . . . . . . . . . . . . . . . . . . . . . E/S formatt ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

59 61 63 65 65 66 68 69 70

3.4.3 3.4.4 3.5

Contr ole des erreurs en E/S

Trouver des erreurs dans un programme . . . . . . . . . . . . . 3.5.1 3.5.2 3.5.3 3.5.4 3.5.5 Les eviter et les d etecter . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Erreurs d etect ees ` a la compilation

Erreurs d etect ees ` a lex ecution . . . . . . . . . . . . . . Erreurs dalgorithme . . . . . . . . . . . . . . . . . . .

Les debuggers . . . . . . . . . . . . . . . . . . . . . .

Programmation modulaire 4.1 Introduction 4.1.1 4.1.2 4.2 4.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

71 71 71 71 72 72 72 73 75 81

Quest-ce-que cest ?

Int er et . . . . . . . . . . . . . . . . . . . . . . . . . . .

Les proc edures internes . . . . . . . . . . . . . . . . . . . . . . Les proc edures externes 4.3.1 4.3.2 . . . . . . . . . . . . . . . . . . . . .

Pourquoi externes ? . . . . . . . . . . . . . . . . . . . Utilisation : probl` eme dinterface . . . . . . . . . . . . .

4.4 4.5

Les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . Compilation s epar ee . . . . . . . . . . . . . . . . . . . . . . .

Utilisation avanc ee 5.1 5.2 5.3 5.4 5.5 5.6 5.7 Types d eriv es . . . . . . . . . . . . . . . . . . . . . . . . . . . Pr ecision des r eels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

89 90 92 94 96 100 105 106

Fonctions de fonctions

Interface g en erique . . . . . . . . . . . . . . . . . . . . . . . . Cr eation de nouveaux op erateurs . . . . . . . . . . . . . . . . . Ressources priv ees, publiques, semi-priv ees . . . . . . . . . . .

Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

R ef erences

107

Appendice : Liste de quelques fonctions intrins` eques usuelles

108

1
1.1

Introduction
Quest-ce quun programme informatique ?

tout commence par un algorithme : suite dop erations donnant un r esultat nal exemple : approximation de 2 par m ethode de Newton
u0 donn e un 1 calculer u = + , pour n = 0 a 10. n+1 2 un

ces op erations sont ecrites dans un chier, avec un langage informatique (pour nous, le fortran 90 (f90)) ce chier constitue le programme ; cest une suite dop erations sur des variables, et eventuellement des echanges de donn ees entre utilisateur et ordinateur ; les variables sont des noms correspondant ` a de la place m emoire dans lordinateur, utilis ee pour stocker les donn ees et les manipuler.

 exemple : approximation de 2 program racine i m p l i c i t none

! --variables

integer : : n real : : u
! --initialisation

u =1.0
! --boucle

do n =1 ,10 u=u / 2 . 0 + 1 . 0 / u end do

! --affichage

p r i n t , approx . de s q r t ( 2 ) : , u end program racine

 ce programme nest pas utilisable tel quel : il faut le rendre compr ehensible par lordinateur, c.-` a-d. le traduire : le logiciel traducteur est appel e compilateur, la traduction est appel ee compilation. exemple : gfortran -o prog prog.f90 prog.f90 : chier contenant le programme ecrit en f90 prog : traduction (appel e chier ex ecutable) le chier ex ecutable permet dex ecuter les instruction programm ees. exemple : ./prog

1.2

Le langage F90 : g en eralit es

ensemble de r` egles syntaxiques et grammaticales et de mots permettant d ecrire des op erations math ematiques, de communiquer des informations entre lordinateur (m emoire), les chiers (disque dur) et lutilisateur (clavier/ ecran). lessentiel du cours va porter sur lapprentissage de ce langage : en commen cant par une vue rapide et simpli ee permettant de pouvoir programmer apr` es une ou deux s eances ; puis en d ecouvrant ensuite les aspects plus complexes du langage. conventions typographiques utilis ees dans ce document : en gras pour les mots-clefs, entre crochets [] pour les instructions optionnelles, en italique pour les commandes unix, en teletype pour les lignes fortran.

 historique : premier compilateur (langage de haut niveau) en 1957, evolutions constantes depuis (voir wikipedia) :
1978 : Fortran 77, tr` es r epandu aujourdhui encore dans les gros codes de calculs 1990 : Fortran 90, fortran devient un langage moderne (format libre, programmation modulaire) fortran 95, 2000 (programmation orient ee objet), 2004, ...

F90 ou C++ pour le calcul scientique : la majeure partie des gros codes de calcul industriel sont ecrits en fortran ... Attention aux eets de mode (Fortran est d epass e, vous programmez encore en fortran ?, il faut programmer en C++) :
fortran est bien plus simple dutilisation les concepts de C++ ne sont gu` ere utiles pour le calcul scientique en g en eral les aspects programmation orient ee objet du C++ sont maintenant utilisables en fortran (depuis fortran 90 et fortran 2003) de nouveaux compilateurs fortran sont d evelopp es pour les nouvelles architectures (fortran pour les GPU par exemple). attention aux commentaires de ceux qui ne connaissent que le C (et de ceux qui ne connaissent que le fortran !) voir le blog dun physicien qui connait bien les deux langages : http://qd.typepad.com/4/2005/08/c_vs_fortran.html

10

2
2.1 2.2

Premiers pas en F90

Exemple de programme structure

program nom_du_programme declaration des variables instructions end program nom_du_programme

2.3

Les variables

variables : noms (cha nes de caract` eres alphanum eriques plus quelques autres, cf. section 2.4) permettant de manipuler des donn ees en m emoire. op eration essentielle : laectation (symbole =) exemple : variable n (entier) : n=2 n=n+1
! -! -prend la augmente valeur de 1 2

ce nest pas une egalit e mais une op eration : la valeur de n stock ee en m emoire est remplac ee par elle-m eme plus 1.
11

 le bloc d eclaration des variables sert ` a indiquer ` a la machine quel est le type de chaque variable utilis ee an de r eserver la place en m emoire n ecessaire. exemple :
d eclaration integer :: n,i real :: x,y signication entier r eel complexe caract` ere bool een ex. daectation n=10 x=1.0e-5 y=1.0 complex :: z character :: c logical :: b z=cmplx(1.0,2.5e3) c=d b=.true.

d eclaration implicite : bien que f90 ne lexige pas, il est prudent de d eclarer toutes les variables. Pour eviter les oublis, placer linstruction implicit none au d ebut du bloc d eclaration. Les oublis sont alors d etect es ` a la compilation.

12

 les tableaux : tous les types pr ec edents peuvent etre structur es en tableaux avec lattribut dimension i n t e g e r , dimension ( 2:2) : : dim r e a l , dimension ( 1 : 3 , 0 : 4 , 1 : 2 0 ) : : tab c h a r a c t e r , dimension ( 1 : 3 , 4 : 6 ) : : tch chaque argument de dimension indique les bornes de la dimension correspondante par un intervalle entier min:max acc` es aux composantes : dim (0)=10 tab ( 2 , 3 , 2 0 ) = 2 . 3 e5 tch (1 ,5)= a

13

2.4

les identicateurs

caract` eres du clavier permettant de nommer une variable ou un autre el ement du programme ; suite de 1 ` a 31 caract` ere alphanum eriques parmi : lettres sans accents majuscules et minuscules, chires, e) ; caract` ere (soulign le 1er caract` ere doit etre une lettre ; les majuscules et minuscules ne sont pas di erenti ees ; exemple : les identicateurs suivants sont valides : constante_gaz pi2 Rk54 les identicateurs suivants ne sont pas valides : accentu e avec espace Il_y_a_plus_de_trente_et_un_caracteres _souligne_devant 1 _chiffre_devant nom#alphanumerique

14

2.5

Continuation de ligne : caract` ere &

une ligne dinstructions comporte au maximum 132 caract` eres si plus de 132 message derreur :
Error : Unterminated character constant beginning at (1) write(*,*) Au clair de la lune, mon ami Pierrot. Prete moi ta plume, pour ecrire un mot. Ma chandelle est morte, je n ai plus de feu. Ouvre moi la porte pour l amour de dieu 1

solution : couper la ligne en morceaux. Placer & en n de premi` ere ligne et & au d ebut de la ligne suivante :
w r i t e ( ,) & & & Au c l a i r de l a l u n e , mon ami P i e r r o t . & Prete moi t a plume , p o u r e c r i r e un mot . & Ma c h a n d e l l e e s t morte , j e n a i p l u s de & f e u . Ouvre moi l a p o r t e p o u r l amour de d i e u

15

2.6

Les commentaires : symbole !

tout ce qui est ` a droite du symbole ! est ignor e par le compilateur cela permet d ecrire des commentaires dans le programme, c.-` a-d. du texte qui en explique le fonctionnement le ! peut etre plac e nimporte o` u dans la ligne (au d ebut, au milieu, ` a la n), et ` a nimporte quel endroit du programme exemple : voir le programme page 30.

16

2.7

Les structures de contr ole

Ce sont des instructions qui permettent de faire des it erations ou des tests sur des variables. 2.7.1 Le test if
x ln x si x=0 0 sinon

exemple : calcul de la valeur y = i f ( x /=0.0) then y = x log ( x ) else y = 0.0 end i f syntaxe g en erale :

i f ( expression logique ) then instructions [ e l s e i f ( expression logique ) then instructions ] [ else instructions ] end i f [ nom ] o` u nom permet de donner un nom ` a la structure pour une meilleure lisibilit e du programme (par exemple en cas de if imbriqu es)
17

[ nom : ]

 expression logique est une combinaison dun ou plusieurs tests sur des variables, ainsi que des trois op erateurs logiques test == /= > < >= <= . and. . or. . not. signication egal di erent sup erieur strict inf erieur strict sup erieur ou egal inf erieur ou egal et ou non

les variables de type logical peuvent aussi etre utilis ees le else if et le else sont optionnels

18

 autre exemple : calcul de y =

0 si x<0 ou x>2 x si x[0,1] 1 si x>1

rac : i f ( x < 0 . 0 . or . x > 2.0) then y = 0.0 e l s e i f ( x < =1.0) then y=sqrt ( x ) else y =1.0 end i f rac

19

2.7.2

La s election select case

pour choisir une instruction ` a ex ecuter en fonction de la valeur dune expression scalaire de type entier, caract` ere ou logique exemple :
c h a r a c t e r ( l e n =30) : : pays ... langue : s e l e c t c a s e ( pays ) c a s e ( f r a n c e , quebec , s u i s s e , b e l g i q u e ) p r i n t , bonjour c a s e ( royaumeu n i , usa ) print , hello case d e f a u l t p r i n t , l a n g u e pas d i s p o n i b l e end s e l e c t langue

lexpression test ee doit v erier au plus un case le case default nest pris en compte que si lexpression ne v erie aucun case

20

2.7.3

It erations : structure do

forme enum erative (nombre dit erations x e) n xi exemple : calcul de y = i i=1 integer : : i , n real : : x , y ... y =0.0 do i =1, n y=y+x i / i end do syntaxe : [ nom : ] do variable=debut , fin [ , pas ] instructions end do [ nom ] autre exemple : calcul de s = 1 + 3 + 5 + 7 + 9 integer : : i , s ... s=0 do i =1 ,9 ,2 s=s+i end do

21

 forme innie : on ne sort quavec linstruction exit [ nom : ] do instructions i f ( condition ) then e x i t [ nom ] end i f instructions end do [ nom ] exemple : do read , nombre i f ( nombre ==0) then exit end i f somme = somme + nombre end do

22

 forme conditionnelle : arr et si la condition sp eci ee en d ebut de boucle est satisfaite [ nom : ] do w h i l e ( condition ) instructions end do [ nom ] exemple : reponse= o u i lecture : do w h i l e ( reponse== o u i ) print , continuer ? read , reponse end do lecture

23

2.8

Les entr ees-sorties ecran/clavier

lecture au clavier de la valeur dune variable, quel que soit son type read,variable ecriture ` a l ecran dun message et/ou de la valeur dune variable print , bonjour print , x print , il est , h , heures exemple : integer : : n c h a r a c t e r ( l e n =15) : : pays ... p r i n t , q u e l age avez vous ? read , n p r i n t , vous ave z , n , ans p r i n t , de q u e l pays e t e s vous ? read , pays p r i n t , vous ve n e z de , pays

24

2.9

Compilation

pour faire fonctionner un programme ecrit en f90, il faut le traduire en un langage compr ehensible par lordinateur : cest la compilation. cette compilation est eectu ee par un compilateur. Dans ce cours, nous utiliserons le compilateur libre gfortran. la compilation cr ee un chier dit ex ecutable. exemple : le programme sappelle calcul, il est ecrit dans le chier toto.f90. On souhaite compiler ce programme pour cr eer un ex ecutable nomm e ici compute. On tape donc la commande gfortran -o compute toto.f90 plus g en eralement, la commande de compilation est : gfortran -o executable chier fortran o` u executable est le nom que lon souhaite donner au chier ex ecutable et chier fortran est le nom du chier qui contient le programme f90 (il est conseill e de donner au chier le m eme nom que le programme, en rajoutant lextension .f90). di erentes options existent, cf. section 3.

25

 messages derreurs : le compilateur d etecte certaines erreurs (syntaxe, conformit e de types, de dimensions) il ache un message donnant le num ero de la ligne contenant lerreur, avec une br` eve explication en anglais exemple : (programme contenu dans le fichier erreur exemple.f90)
erreur_exemple.f90:7.3: y = x*log(x) 1 Error: Symbol y at (1) has no IMPLICIT type

une erreur en provoque souvent dautres (exemple : une variable non d eclar ee va g en erer des erreurs ` a chaque ligne o` u elle est utilis ee) la liste des erreurs est donc souvent tr` es longue, et il faut alors commencer par corriger les premi` eres de la liste, puis recompiler.

26

 les messages derreurs ne sont pas toujours tr` es clairs ... exemple : dans un programme contenu dans le chier erreur declaration.f90, on fait une erreur de frappe dans la d eclaration suivante : ineger :: n au lieu de : integer :: n ce qui provoque le message suivant :
erreur_declaration.f90:5.2: ineger :: n 1 Error: Unclassifiable statement at (1)

27

2.10

Ex ecution

si le chier contenant lex ecutable sappelle prog , alors taper simplement ./prog erreurs ` a lex ecution toutes les erreurs ne sont pas d etect ees ` a la compilation (certaines options peuvent cependant y aider) divisions par 0, erreurs daectation de tableau erreurs dalgorithme (+ au lieu de ) il faudra apprendre ` a trouver ces erreurs en faisant des tests, et en utilisant un debugger (cf. sec. 3.5.5).

28

2.11

Ecrire un programme proprement

ecrire des commentaires (but et fonctionnement du programme, signication des variables, d ecrire chaque bloc dinstruction) indenter correctement (en particulier les structures de contr ole) nommer les boucles imbriqu ees d eclarer les variables dans lordre croissant des structures (logiques, entiers, caract` eres, r eels, puis tableaux) mieux vaut utiliser des noms de variables longs mais clairs que des noms courts et obscurs e dutiliser l editeur de texte il est fortement conseill Emacs pour programmer. Outre sa puissance d edition en g en eral (au moyen de raccourcis clavier qui permettent de taper du texte tr` es rapidement), il poss` ede des fonctions adapt ees ` a la programmation : indentation automatique, compl etion des noms de programmes et de boucles, coloration des mots clefs, etc. Voir le guide Emacs distribu e en cours [5].

29

2.12

Exemple complet

calcul de la solution de x ex = 0 par la m ethode de Newton. algorithme : x0 et tol donnes (xn exn ) calculer xn+1 = xn 1 + exn xn+1 xn | tol tant que | xn
program zero i m p l i c i t none ! --- variables r e a l : : x , y , diff , tol ! --- lecture des donn e es print , entrer le x i n i t i a l read , x print , tole rance r e a d , tol

! --- m e thode de newton newton : do ! -- it e ration y=x ( xexp ( x ) ) / ( 1 . 0 + exp ( x ) ) ! -- diff e rence entre deux it e r es

30

i f ( x / = 0 . 0 ) t hen diff=abs ( ( xy ) / x ) else diff=abs ( xy ) end i f ! -- mise ` a jour x=y ! -- test de convergence i f ( diff <tol ) t hen exit end i f end do newton p r i n t , s o l u t i o n approch e e= , x end program zero

31

3
3.1

Un peu plus loin ...

Variables constantes

Pour d eclarer une variable constante (c.-` a-d. qui a une valeur non modiable) : attribut parameter la variable est non modiable, sinon erreur d etect ee a la compilation ` utile pour d eclarer et prot eger des constantes physiques exemple : real , parameter :: pi=3.14159265, N=6.02252e23 dans la d eclaration, les op erations usuelles sont utilisables, mais pas lappel de fonction : real , parameter :: quart=1.0/4.0 !--- valide real , parameter :: pi=acos(1.0) !--- non valide

32

3.2
3.2.1

Sous-programmes
Objectif

bloc dinstructions utilis e plusieurs fois l ecrire dans un sous-programme une fois pour toutes, et lappeler quand n ecessaire (aussi appel e proc edure) deux types de sous-programme : les subroutines et les fonctions

33

 exemple 1 : subroutine
program exproc i m p l i c i t none r e a l : : moyenne , maximum r e a l , d i m e n s i o n ( 1 0 0 ) : : tab c a l l r a n d o m _ n u m b e r ( tab ) c a l l sp ( tab , moyenne , maximum ) p r i n t , moyenne , maximum contains s u b r o u t i n e sp ( t , moy , max ) i m p l i c i t none real , dimension (100) , i n t e n t ( i n ) : : t r e a l , i n t e n t ( o ut ) : : moy , max integer : : i max = t ( 1 ) ; moy = t ( 1 ) do i =2 ,100 i f ( t ( i ) > max ) t hen max = t ( i ) end i f moy = moy + t ( i ) end do moy = moy /100 end s u b r o u t i n e sp end program exproc

34

 exemple 2 : fonction
program exfct i m p l i c i t none r e a l : : maximum r e a l , d i m e n s i o n ( 1 0 0 ) : : tab c a l l r a n d o m _ n u m b e r ( tab ) maximum = maxi ( tab ) p r i n t , maximum contains f u n c t i o n maxi ( t ) i m p l i c i t none real , dimension (100) , i n t e n t ( i n ) : : t integer : : i r e a l : : maxi ! - la fonction est d e clar ee maxi = t ( 1 ) do i =2 ,100 i f ( t ( i ) > maxi ) t hen maxi = t ( i ) endif end do end f u n c t i o n maxi end program exfct

35

3.2.2

Fonctionnement

place dans le programme : avant la derni` ere ligne end program nom_programme et apr` es le mot-clef contains program nom_programme declarations instructions contains s u b r o u t i n e nom_subroutine ... end s u b r o u t i n e nom_subroutine f u n c t i o n nom_fonction ... end f u n c t i o n nom_fonction end program nom_programme on parle alors de sous-programme interne (par opposition aux sous-programmes externes, cf. section 4.3) port ee des variables : toutes les variables du programme principal sont connues de ses sous-programmes internes. Pas besoin de red eclaration, sauf pour les arguments (voir plus loin). les variables utilis ees seulement par un sous-programme (variables locales) : d eclar ees ` a lint erieur de celui-ci, comme dans un programme principal. Connues de lui seul.
36

 appel dun sous-programme : subroutine : appel ee par linstruction call call nom_subroutine ( arguments )

fonction : appel ee comme une fonction math ematique : y=nom_fonction ( arguments )

3.2.3

Arguments dune subroutine

subroutine : sous-programme ayant ou non des arguments dentr ee et de sortie : variables ` a d eclarer a ` lint erieur de la subroutine il est conseill e de pr eciser dans ces d eclarations les attributs suivants intent( in ) pour les arguments dentr ee intent(out) pour les arguments de sortie intent(inout) pour les arguments mixtes. Ainsi le compilateur d etecte une mauvaise utilisation des arguments (entr ee modi ee, sortie non donn ee, etc.)

37

3.2.4

Arguments dune fonction - d eclaration du r esultat

fonction : comme une subroutine, mais arguments dentr ee obligatoires renvoie n ecessairement un r esultat, stock e dans une variable ayant le m eme nom que la fonction

38

 le type du r esultat peut etre donn e soit avant le nom de la fonction (sauf si r esultat tableau) :
r e a l f u n c t i o n maxi ( t ) ... end f u n c t i o n maxi

soit dans une d eclaration :

f u n c t i o n maxi ( t ) ... r e a l : : maxi ... end f u n c t i o n maxi

le r esultat peut avoir un nom di erent du nom de la fonction, en utilisant la clause result
f u n c t i o n maxi ( t ) r e s u l t ( y ) ... real : : y ... end f u n c t i o n maxi

dans ce cas, pas de type avant le mot clef function. la variable r esultat ne doit pas avoir dattribut intent

39

3.2.5

Les tableaux en arguments

probl` eme : dans lexemple de la page 34, la subroutine sp naccepte que des tableaux de taille 100. Comment faire pour quelle fonctionne avec des tableaux de tailles quelconques ? le plus simple : donner en entr ee le tableau et ses dimensions (assumed size array en anglais) :
program exproc ... r e a l , d i m e n s i o n ( 1 0 0 ) : : tab ... contains s u b r o u t i n e sp ( t , n , moy , max ) ... integer , intent ( in ) : : n real , dimension ( 1 : n ) , i n t e n t ( i n ) : : t r e a l , i n t e n t ( o ut ) : : moy , max integer : : i max = t ( 1 ) ; moy = t ( 1 ) do i =2 , n ... end do moy = moy /100 end s u b r o u t i n e sp end program exproc

40

 autre exemple : program toto ... r e a l , dimension ( 1 : 3 , 1 : 2 ) : : A ... c a l l sousprog ( A , 3 , 2 ) ... contains s u b r o u t i n e sousprog ( A , m , n ) integer , intent ( in ) : : m , n r e a l , dimension ( 1 : m , 1 : n ) : : A ... end s u b r o u t i n e sousprog end program toto

41

 on peut aussi ne passer que le tableau en argument et r ecup erer ensuite ses dimensions (tableau ` a prol implicite, assumed shape array en anglais). Attention alors ` a la d eclaration :
program exproc ... r e a l , d i m e n s i o n ( 1 0 0 ) : : tab ... contains s u b r o u t i n e sp ( t , moy , max ) ... real , dimension ( : ) , i n t e n t ( i n ) : : t r e a l , i n t e n t ( o ut ) : : moy , max integer : : i , n n= s i z e ( t ) max = t ( 1 ) ; moy = t ( 1 ) do i =2 , n ... end do moy = moy /100 end s u b r o u t i n e sp end program exproc

42

 autre exemple :
program toto ... real , dimension ( 1 : 3 , 1 : 2 ) : : A , B real , dimension ( 1 : 3 ) : : u , v ... c a l l sousprog ( A , B ) ... v=fct ( u ) ... contains s u b r o u t i n e sousprog ( A , B ) real , dimension ( : , : ) , i n t e n t ( i n ) : : A r e a l , d i m e n s i o n ( : , : ) , i n t e n t ( o ut ) : : B integer : : m , n m= s i z e ( A , 1 ) ; n= s i z e ( A , 2 ) B=A 2 end s u b r o u t i n e sousprog f u n c t i o n fct ( u ) r e s u l t ( v ) real , dimension ( : ) , i n t e n t ( i n ) : : u real , dimension ( s i z e ( u ) ) : : v ... end f u n c t i o n fct end program toto

ATTENTION : le prol implicite sutilise seulement pour les tableaux arguments. Pour des tableaux locaux ou un r esultat de fonction dont les tailles d ependent de celles des arguments, remarquer lutilisation de linstruction size .

43

3.2.6

Les cha nes en arguments

m eme principe que pour les tableaux : on peut passer en argument la cha ne et sa longueur on peut aussi utiliser un prol implicite, pour les arguments uniquement exemple :
program chaine ... c h a r a c t e r ( l e n =20) : : ch p r i n t , ch , f2 ( ch , 2 0 ) p r i n t , f1 ( ch ) contains f u n c t i o n f1 ( ch ) i m p l i c i t none c h a r a c t e r ( l e n = ) , i n t e n t ( i n ) : : ch c h a r a c t e r ( l e n = l e n ( ch ) ) ) : : f1 ... end f u n c t i o n eff_blanc f u n c t i o n f2 ( ch , n ) i m p l i c i t none integer , intent ( in ) : : n c h a r a c t e r ( l e n =n ) , i n t e n t ( i n ) : : ch i n t e g e r : : f2 ... end f u n c t i o n nb_blancs end program chaine

44

3.3
3.3.1

Tableaux
Tableaux statiques

d ej` a vu : les dimensions sont x ees ` a la d eclaration : real , dimension(1:10,1:4) :: A 3.3.2 Allocation dynamique

il est fr equent que les tailles des tableaux utilis es dans un programme d ependent de donn ees et ne soient pas connues ` a la compilation moyen simple et ecace : attribut allocatable (tableau allouable) : r e a l , dimension ( : , : ) , a l l o c a t a b l e : : A le nombre de dimensions est donn e (ici 2), mais pas les dimensions elles-m emes pour manipuler ces tableaux, on commence par les allouer en m emoire (c.-` a-d. la place n ecessaire est r eserv ee), en donnant leurs dimensions. Exemple : integer : : n , m ... read , n , m allocate (A (1: n , 1 : m))

45

 pour changer la taille du tableau : le d esallouer, puis le r eallouer : deallocate (A) allocate (A (1:3 ,0:4)) evidemment, on ne peut utiliser un tableau non encore allou e. ne pas oublier de lib erer la place m emoire avec deallocate quand le tableau nest plus utilis e (en particulier pour les tableaux locaux dans des sous-programmes, sinon, risque de d epassement de m emoire). 3.3.3 Allocation dynamique dans un sous-programme : tableaux automatiques

autre moyen simple de cr eer un tableau dont la taille nest pas connue ` a la compilation utilisable seulement au sein dun sous-programme principe : les dimensions du tableau sont des variables pass ees en arguments du sous-programme (automatic array en anglais). Exemple : s u b r o u t i n e autom ( m , n ) ... integer : : m , n r e a l , dimension ( m , n ) : : A

46

 avantage : plus rapide en ex ecution que la cr eation dun tableau allouable. A utiliser pour les sous-programmes appel es tr` es fr equemment. Les instructions fortran sont aussi plus simples ` a ecrire. inconv enient : aucun moyen de v erier sil y a assez de place pour cr eer le tableau, contrairement aux tableaux allouables. Le message derreur correspondant est g en eralement tr` es obscur. pour les tableaux de grandes tailles utilis es peu fr equemment, il est donc plut ot conseill e dutiliser les tableaux allouables. 3.3.4 Terminologie

rang : nombre de dimensions (le rang de A est 2) taille dune dimension : nombre d el ements dans cette dimension (les tailles des dimensions de A sont 3 et 5) forme : suite ordonn ee des tailles des dimensions (la forme de A est 3,5) une taille peut etre nulle

47

3.3.5

Op eration conformes entre tableaux

but : faire des op erations sur des tableaux sans ecrire les op erations el ement par el ement deux tableaux sont conformes sils ont m eme forme : A (1:10,1:4) et B (3:12,0:3) sont conformes A (1:10,1:4) et B (3:12,1:3) ne sont pas conformes A (1:1,1:1) et B (1:1) ne sont pas conformes une expression est conforme si elle fait intervenir des tableaux conformes un scalaire est consid er e comme conforme ` a tout tableau la plupart des op erations scalaires sont applicables aux tableaux : op eration appliqu ee el ement par el ement, r esultat de m eme forme que les tableaux op erandes

48

 exemples :
program conforme i m p l i c i t none integer : : i , j r e a l , dimension ( 3 , 3 ) : : A , B , C c a l l random_number ( A ) c a l l random_number ( B ) C=A+B +2.0 ! -- op . equivalente a ` print ,C do i =1 ,3 do j =1 ,3 C ( i , j )= A ( i , j )+ B ( i , j )+2.0 end do end do print ,C C=A B ! -- pas prod . matriciel print ,C C=sqrt ( B ) C print ,C C=B+cos ( B 3 . 1 4 1 6 ) print ,C A=1sin ( log ( B+A ) ) print ,A end program conforme

49

3.3.6

Cr eer des tableaux ` a la main

avec une liste de variables dun m eme type var1, var2 ,..., varn, on peut cr eer un vecteur (tableau de rang 1) avec le constructeur (/.../) : v =(/ var1 , var2 , . . . , varn / ) la liste peut-elle m eme etre cr e ee avec une boucle implicite v =(/( i 2 , i =1 ,4)/) v =(/1 ,4 ,9 ,16/)
! - - equivaut a `

on peut imbriquer plusieurs boucles implicites v =(/(( i+j , j =1 ,2) , i =1 ,3)/) v =(/2 ,3 ,3 ,4 ,4 ,5/)
! - equivaut a `

50

 comme dans une boucle do on peut donner un pas : v =(/( i , i = 1 , 1 1 , 2 ) / ) v =(/1 ,3 ,5 ,7 ,9 ,11/)
! -- equivaut a `

pour transformer un vecteur en tableau ` a plusieurs dimensions : fonction reshape(vecteur,forme_du_tableau ) r e a l , dimension ( 2 , 3 ) : : A A=reshape ( v , ( / 2 , 3 / ) ) donne la matrice A = colonne) 3.3.7
15 9 3 7 11

(remplie colonne par

Les sections de tableaux

on acc` ede ` a une section de tableau en modiant convenablement les indices de d ebut et de n des dimensions : r e a l , dimension ( 1 : 1 0 , 1 : 2 0 ) : : A A(2:6 ,1:20) ! -- lignes de 2 a ` 6 A(2:6 ,:) ! -- idem A(i , : ) ! -- ieme ligne A (: , j) ! -- jeme colonne A(2:6 ,1:4) ! -- el ement communs
! ! lignes 2 a ` 6 et colonnes 1 a ` 4

aux

51

3.3.8

Stockage des tableaux dans la m emoire et ordre des boucles

il est tr` es important lorsquon manipule de gros tableaux de savoir comment ils sont stock es en m emoire exemple : y-a-til une di erence importante entre les deux blocs suivants ? do i =1, m do j =1, n c ( i , j )= a ( i , j )+ b ( i , j ) enddo enddo do j =1, n do i =1, m c ( i , j )= a ( i , j )+ b ( i , j ) enddo enddo oui : le premier bloc est beaucoup plus co uteux en temps !

52

 quel que soit le nombre de dimensions dun tableau, il est stock e en m emoire sous forme uni-dimensionnelle. Les el ements sont stock es ainsi :
a(1,1) ... a(2,1) a(1,n) a(3,1) a(2,n) ... a(3,n) a(m,1) ... a(1,2) a(m,n) a(2,2) a(3,2) ...

exemple : les el ements du tableau suivant integer , dimension(2,4) :: a sont rang es ainsi :
a (1,1) a (2,1) a (1,2) a (2,2) a (1,3) a (2,3) a (1,4) a (2,4)

a(1,1) a(1,2) a(1,3) a(1,4)

a(1,1)

a(1,2)

a(1,3)

a(1,4)

a(2,1) a(2,2) a(2,3) a(2,4)

a(2,1)

a(2,2)

a(2,3)

a(2,4)

conclusion : quand on parcourt les el ements dun tableau, il faut que la boucle sur la premi` ere dimension soit la boucle la plus interne (ceci est li e` a la notion de cache dans la m emoire) cest linverse de ce qui se fait en C, et de ce qui se fait en g en eral quand on ecrit les algorithmes voir en TP pour une comparaison en temps calcul des deux strat egies.

53

3.4

Entr ees-sorties (E/S)

On a vu dans la premi` ere partie comment lire au clavier et ecrire ` a l ecran. Ici, on va voir comment lire et ecrire dans un chier. 3.4.1 E/S en format libre, dans un chier texte ` a acc` es s equentiel

Cest le plus simple, equivalent de ce quon a vu avec l ecran/clavier ouverture du chier toto : open ( u n i t =10 , f i l e = t o t o ) cette instruction ouvre le chier ` a la premi` ere ligne (sil nexiste pas, il est cr e e). lexpression unit=10 indique que le chier toto est connect e au descripteur num ero 10. tous les nombres peuvent etre utilis es comme descripteurs sauf 5 (clavier) et 6 ( ecran). si le mot clef le nest pas donn e, le chier fort.n est cr e e, o` u n est le descripteur donn e apr` es le mot clef unit.

54

 ecriture de donn ees dans toto (si associ e au descripteur 10) : w r i t e ( 1 0 , ) donnee1 , donnee2 , donnee3 une instruction write ecrit toutes les donn ees sur la m eme ligne, le write suivant passera ` a la ligne suivante. les donn ees peuvent etre de nimporte quel type (constantes ou variables) le print , pour ecrire ` a l ecran est equivalent a ` write(6,*) et ` a write(*,*)

55

 lecture de donn ees dans toto (si associ e au descripteur 10) : read ( 1 0 , ) var1 , var2 , var3 la premi` ere ligne de toto est lue, le read suivant passera ` a la ligne suivante. les donn ees sont suppos ees etre s epar ees par des blancs. elles sont stock ees respectivement dans var1, var2, ..., varn. si plus de donn ees que de variables : seules les premi` eres donn ees sont stock ees (cas inverse : seules les premi` eres variables sont aect ees) le read, pour lire au clavier est equivalent ` a read(5,) et ` a read(,). fermeture du chier toto : close (10) attention, si on r eouvre le chier avec open, on se retrouve ` a la premi` ere ligne. ecrasement de chier : un write apr` es louverture dun chier existant d etruit le contenu du chier.
56

 exemple 1 : chier titi.txt :

bonjour 4 heures temperature 37.2

programme :
c h a r a c t e r ( l e n =14) : : c1 , c2 , c3 integer : : n real : : T open ( u n i t =10 , f i l e = t i t i . t x t ) r e a d ( 1 0 , ) c1 , n , c2 ! -- lecture 1 ere ligne r e a d ( 1 0 , ) c3 , T ! -2 eme ligne close (10) open ( u n i t =20 , f i l e = t o t o . t x t ) ! -- ecriture 1 ere ligne w r i t e ( 2 0 , ) c1 , i l e s t , n , c2 ! -- ecriture 2 eme ligne w r i t e ( 2 0 , ) l a , c3 , e s t de , T , d e g r e s close (20)

apr` es ex ecution, chier toto.txt :

bonjour il est la temperature est de 4 heures 37.20000 degres

57

 exemple 2 : dans le chier info.txt, liste de 1000 personnes avec un nom, age et taille sur chaque ligne. Programme de lecture :
integer : : i c h a r a c t e r ( l e n =30) , d i m e n s i o n ( 1 : 1 0 0 0 ) : : nom i n t e g e r , d i m e n s i o n ( 1 : 1 0 0 0 ) : : age r e a l , d i m e n s i o n ( 1 : 1 0 0 0 ) : : taille open ( u n i t =30 , f i l e = i n f o . t x t ) do i =1 ,1000 read ( 3 0 , ) nom ( i ) , age ( i ) , taille ( i ) end do close (30)

58

3.4.2

E/S dans un chier binaire ` a acc` es s equentiel

les chiers de textes sont des chiers de caract` eres, ce qui peut prendre beaucoup de place sil y a beaucoup de donn ees. dans ce cas, il vaut mieux stocker les donn ees (en particulier num eriques) sous forme binaire. Le chier nest pas lisible avec un editeur de texte, mais il est beaucoup plus petit. ouverture : avec open comme pour un chier texte en pr ecisant le param` etre form=unformatted :
open ( u n i t =15 , f i l e = t o t o , form= unf o r m a t t e d )

lecture/ ecriture : open et write sans le param` etre : read ( 1 5 ) var1 , var2 w r i t e ( 1 5 ) donnee

59

 exemple : tableau de r eels al eatoires, stock e dans un chier texte et dans un chier binaire. Comparer les tailles des deux chiers.
real , dimension (1: 1000) : : tableau

c a l l r a n d o m _ n u m b e r ( tableau ) open ( u n i t =1 , f i l e = t e x t e . t x t ) w r i t e ( 1 , ) tableau close (1) open ( u n i t =2 , f i l e = b i n a i r e . b , form= unf o r m a t t e d ) w r i t e ( 2 ) tableau close (2)

60

3.4.3

E/S formatt ees

inconv enient de E/S en format libre : chier pas propre : r eels ecrits sous forme d ecimale si > 102 , sous forme scientique sinon (cf le chier texte.txt de la section 3.4.2). format : on indique pr ecis ement le nombre et le type des variables ` a lire et ecrire param` etre fmt de read et write :
read ( descripteur , fmt= ( c h a i n e ) ) var1 , . . . w r i t e ( descripteur , fmt= ( c h a i n e ) ) var1 , . . .

lecture peu sure : risque de m elange des variables

o` u chaine indique le type des donn ees dans lordre o` u elles sont lues ou ecrites formats de base (plus de d etails sur [3]) :
fmt=(nFm.d) : n r eels sous forme d ecimale, form es de m caract` eres (dont le .), dont d apr` es la virgule fmt=(nEm.d) : n r eels sous forme scientique, form es de m caract` eres, dont d apr` es la virgule (dont le .) fmt=(nAm) : n cha nes de m caract` eres fmt=(nIm) : n entiers de m chires

Dans tous les cas, cest le caract` ere espace qui s epare les n champs. exemple :
61

c h a r a c t e r ( l e n =10) : : prenom , nom i n t e g e r : : age prenom= JEAN nom= DURAND age =20 w r i t e ( , fmt= ( 2 A10 , 1 I 3 ) ) prenom , nom , age

va ecrire : JEAN ALAIN DURAND MARTIN 20 33

si on doit utiliser plusieurs fois un m eme format, on peut stocker la cha ne associ ee au param` etre fmt dans une variable. Exemple : formate= ( 2 A10 , 1 I 3 ) w r i t e ( , fmt=formate ) prenom , nom , age

62

3.4.4

Contr ole des erreurs en E/S

avec les instructions pr ec edentes, le programme sarr ete a la moindre erreur (lecture dans chier inexistant, ` lecture d epassant la taille du chier, ecriture texte dans un chier binaire, etc.) des param` etres des commandes open, read et write permettent d eviter larr et et de d eterminer la source de lerreur. exemple : le param` etre iostat : i n t e g e r : : erreur read ( 1 5 , , i o s t a t =erreur ) ! - f i c h . t e x t e read ( 2 3 , i o s t a t =erreur ) ! - f i c h . b i n a i r e si lecture correcte erreur vaut 0 sinon, si erreur < 0 alors n de chier rencontr ee, sinon autre erreur.

63

 exemple : erreur =0 do w h i l e ( erreur ==0) read ( 1 5 , , i o s t a t =erreur ) var p r i n t , v a r i a b l e= , var end do i f ( erreur < 0) then p r i n t , f i n du f i c h i e r else p r i n t , e r r e u r de l e c t u r e end i f voir les instructions open et write pour la signication de iostat.

64

3.5

Trouver des erreurs dans un programme

Les eviter et les d etecter

3.5.1

1. avant de programmer un algorithme, sassurer quil est correct 2. programmer proprement (voir sec. 2.11), utiliser au maximum les signaux derreurs renvoy es par les commandes (param` etre iostat , etc.), acher des messages derreur en cas dop eration interdite ( x < 0, etc.) 3. lors de la phase de d eveloppement, utiliser des options de compilation pour d etecter les erreurs ` a lex ecution etecte en particulier les d ecomme -fcheck=all qui d passements de tableau) ou -pe-trap=invalid,zero qui d etecte les op erations invalides 4. eectuer des tests judicieux pour tester le programme 5. en d esespoir de cause, rajouter des achages de variables dans le programme, et utiliser linstruction stop pour que le programme sarr ete ` a lendroit voulu. La t ache 5 peut etre simpli ee en utilisant un debugger (voir sec. 3.5.5).

65

3.5.2

Erreurs d etect ees ` a la compilation

le compilateur renvoie un message plus ou moins explicite (voir sec. 2.9) erreur de syntaxe : exemple la compilation sur natty de program erreur_syntaxe i m p l i c i t none integer : x real : : r r =102 end program erreur_syntaxe renvoie les messages suivants :
erreur_syntaxe.f90:4.11: integer : x 1 Error: Invalid character in name at (1) erreur_syntaxe.f90:7.2: r=10^2 1 Error: Unclassifiable statement at (1)

66

 oubli de d eclaration : voir lexemple pr ec edent erreur de dimension : la compilation sur natty de program erreur_dimension i m p l i c i t none r e a l , dimension ( 1 : 4 ) : : a a (4 ,4)=1.0 end program erreur_dimension renvoie les messages suivants
erreur_dimension.f90:6.3: a(4,4)=1.0 1 Error: Rank mismatch in array reference at (1) (2/1)

malheureusement, il existe beaucoup dautres erreurs possibles ...

67

3.5.3

Erreurs d etect ees ` a lex ecution

Il y a evidemment beaucoup derreurs possibles. En voici quelques unes avec le programme suivant program erreur_execution i m p l i c i t none real : : x x =1/3 print ,x x = 1.0 p r i n t , sqrt ( x ) read , x end program erreur_execution En supposant que lutilisateur tape la lettre a au clavier, on aura alors les achages suivants ` a l ecran :
0.0000000 NaN a At line 11 of file erreur_execution.f90 (unit = 5, file = stdin) Fortran runtime error: Bad real number in item 1 of list input

68

 le premier print renvoie 0, car la division est enti` ere (oubli de .0 sur le num erateur et/ou d enominateur). Mais il ny a pas derreur dex ecution ` a proprement parler, puisque le programme continue ` a tourner) le deuxi` eme renvoie NaN (not a number), car la racine dun nombre n egatif nest pas d enie (l` a non plus, pas vraiment de message derreur : le programme continue ` a tourner) le dernier achage est un message derreur : le programme sarr ete (on dit quil plante) ` a cause de la lecture dun caract` ere au lieu du r eel attendu. 3.5.4 Erreurs dalgorithme

Ce sont des erreurs souvent diciles ` a trouver. Cest pourquoi il vaut mieux bien ecrire son algorithme avant de le programmer

69

3.5.5

Les debuggers

La t ache 4 d ecrite ` a la section 3.5.1 peut etre simpli ee avec les logiciels dits debuggers : sans eux, il faut recompiler et ex ecuter le programme apr` es chaque modication, ce qui peut etre long quand le programme est gros ; un debugger permet, sans modier le programme, dacher la valeur des variables au cours de lex ecution, et de stopper temporairement lex ecution ` a lendroit d esir e. lutilisation dun debugger n ecessite un certain investissement, mais cet eort est largement r ecompens e par la suite. Sur la machine natty, le debugger est gdb. Il peut etre utilis e avec linterface graphique ddd (voir le manuel [2] avec un exemple simple et instructif dans la section sample session). Important : pour utiliser un debugger, il faut compiler le programme avec loption -g .

70

4
4.1
4.1.1

Programmation modulaire
Introduction
Quest-ce-que cest ?

programmer de fa con modulaire consiste ` a d ecouper le plus possible un programme en morceaux algorithmiquement ind ependants (appel es sous-programmes) exemple : calculer t = trace(A1 B ). Ce probl` eme contient trois calculs qui peuvent etre programm es ind ependamment : A trace(A)

(A, B ) AB A A1

on essaiera donc de rendre ces morceaux les plus ind ependants possible au niveau informatique. 4.1.2 Int er et

permet de r eutiliser plusieurs fois un morceau de programme facilement le programme est plus lisible le risque derreurs de programmation est moins grand : chaque bloc est ecrit, compil e, et test e s epar ement.
71

 exemple : cr eation dun ensemble de fonctions pour faire des calculs matriciels (produit matrice-vecteur, triangularisation, solution dun syst` eme lin eaire, d eterminant, trace, etc.) on a d ej` a vu un moyen de cr eer des sous-programmes en utilisant les fonctions et subroutines. On va aussi voir les modules.

4.2

Les proc edures internes

d ej` a vu ` a la section 3.2, facile ` a faire probl` eme : pas embo table. Une proc edure interne ne peut pas contenir de sous-programme. Or une proc edure interne peut n ecessiter lutilisation dune autre proc edure interne (exemple : la proc edure de r esolution dun syst` eme lin eaire par m ethode de Gauss n ecessite une proc edure interne de r esolution dun syst` eme triangulaire) probl` eme de lisibilit e : le programme principal peut etre tr` es gros car il contient touts les sous-programmes cette m ethode ne r epond donc pas parfaitement au probl` eme.

72

4.3
4.3.1

Les proc edures externes

Pourquoi externes ?

Ces proc edures sont ecrites ` a lext erieur du programme principal : soit apr` es linstruction end program qui termine le programme principal soit dans un autre chier 4.3.2 Utilisation : probl` eme dinterface

Elles peuvent sutiliser exactement comme une proc edure interne (m eme syntaxe), mais il existe un probl` eme dinterface : programme principal et proc edures sont compil es s epar ement il ny a pas de contr ole de coh erence des arguments entre lappel et la proc edure appel ee : les erreurs eventuelles ne sont donc pas d etect ees ` a la compilation. Elles seront visibles ` a lex ecution, mais seront peut etre diciles ` a localiser. Exemple : types des variables di erents entre lappel et la proc edure appel ee.

73

 on dit que linterface entre programme principal et proc edure appel ee est implicite (contrairement aux proc edures internes ou linterface est dite explicite). cons equence : il est impossible de passer des tableaux ou des cha nes ` a prols implicites dans une proc edure externe avec interface implicite. pour rendre une interface explicite, le plus simple est denfermer la proc edure externe dans un module (il existe dautres solutions moins simples avec les bloc interface, voir [3]).

74

4.4

Les modules

utilis es pour que linterface entre programme principal et proc edure externe soit explicite on enferme la proc edure externe dans un module de la fa con suivante : module nom_du_module i m p l i c i t none contains s u b r o u t i n e nom_subroutine ... end s u b r o u t i n e nom_subroutine end module nom_du_module le module est alors plac e dans un chier (di erent de celui du programme principal) qui a pour nom nom du module.f90 dans le programme utilisant la subroutine, il sut de rajouter linstruction use nom_du_module en tout d ebut de programme, avant linstruction implicit none.

75

 exemple : erreur dargument dans lappel dune proc edure externe 1. interface implicite (sans module) chier test1.f90 program test1 i m p l i c i t none c a l l somme ( o u i , non ) end program test1 chier somme.f90 s u b r o u t i n e somme ( x , y ) i m p l i c i t none real , intent ( in ) : : x , y real : : s s=x+y p r i n t , somme= , s end s u b r o u t i n e somme en entr ee : 2 cha nes au lieu de 2 r eels erreur pas d etect ee ` a la compilation. A lex ecution, on a un r esultat aberrant.
76

2. interface explicite avec module chier test2.f90

program test2 us e mod_somme i m p l i c i t none c a l l somme ( o u i , non ) end program test2

chier mod somme.f90

module mod_somme i m p l i c i t none contains s u b r o u t i n e somme ( x , y ) i m p l i c i t none real , intent ( in ) : : x , y real : : s s=x+y p r i n t , somme= , s end s u b r o u t i n e somme end module mod_somme

77

lerreur est alors d etect ee ` a la compilation :

test2.f90:7.13: call somme(oui,non) 1 Error: Type mismatch in argument x at (1); passed CHARACTER(1) to REAL(4)

78

 autres utilisations des modules permettent de d enir des constantes, des variables, des types d eriv es que lon peut utiliser dans di erents sous-programmes sans les passer en argument. Exemple : chier mod cte math.f90 module mod_cte_math i m p l i c i t none r e a l , parameter : : pi =3.141593 end module mod_cte_math chier aire.f90 program aire use mod_cte_math i m p l i c i t none real : : r , s r =1.0 s=pi r 2 end program aire

79

 permet aussi de passer des proc edures en arguments, pour faire des fonctions de fonctions (voir section 5) conseil : utiliser les modules autant que possible.

80

4.5

Compilation s epar ee

comment compiler un programme quand on a des sousprogrammes externes situ es dans des chiers di erents ? compilation globale utiliser la commande vue sec 2.9 gfortran -o nom executable liste chiers fortrans mais les modules doivent etre compil es avant les sous-programmes utilisateurs. Ils doivent donc etre plac es avant dans la liste inconv enient : une modication dun chier entra ne la re-compilation de tous les chiers

81

 compilation s epar ee : 2 phases successives 1. compilation (option -c) : pour tout chier fortran (ici ch.f90) faire gfortran -c ch.f90 r esultat : cr eation du chier objet ch.o (de m eme nom que le chier fortran mais dextension .o) si ch.f90 contient le module fich, cr eation du chier ch.mod (de m eme nom que le module avec lextension .mod). Contient linterface du module, n ecessaire pour compiler les programmes utilisateurs de fich attention : compiler les modules avant les sousprogrammes utilisateurs 2. edition de liens (option -o) : les chiers objets (.o) sont li es ensemble pour faire lex ecutable gfortran -o nom executable liste chiers objets

82

 int er et : on ne recompile que les chiers modi es et les chiers d ependants, et lon refait l edition de liens outil compl ementaire ecace pour la compilation s epar ee de gros programmes (plusieurs dizaines de chiers) : la commande make (voir la n de cette section)

83

 Exemple : programme fortran90 compos e dun programme principal prog qui utilise deux modules mod1 et mod2. Le module mod1 utilise le module mod2.
prog prog.o (3) mod1.o compilation (2) mod2.o (1) prog.f90 mod1.f90 mod2.f90
fichiers fortran fichiers objets

excutable

(4) dition de liens

mod1.mod

mod2.mod

la compilation s epar ee est : (1) compilation : f90 -c mod2.f90 (2) compilation : f90 -c mod1.f90 (3) compilation : f90 -c prog.f90 (4) edition de liens : f90 -o prog prog.o mod1.o mod2.o

84

 en cas de modication de prog, alors seules la compilation de prog.f90 puis l edition de liens sont n ecessaires (phases (3) et (4))

85

 utilisation de la commande make : le chier suivant (nomm e Makele) contient les d ependances entre chiers et les actions ` a ex ecuter pour mettre ` a jour lex ecutable :
# edition de liens prog : prog.o mod1.o mod2.o <TAB> gfortran -o prog prog.o mod1.o mod2.o # compilation prog.o : prog.f90 mod1.o mod2.o <TAB> gfortran -c prog.f90 mod1.o : mod1.f90 mod2.o <TAB> gfortran -c mod1.f90 mod2.o : mod2.f90 <TAB> gfortran -c mod2.f90

La commande unix make utilise ce chier pour ne compiler que ce qui a et e modi e : il sut de taper cette commande dans le dossier contenant le programme. Attention : la tabulation (visualis ee ci-dessus par <TAB>) est indispensable.

86

 on peut param etrer ce Makele pour utiliser des options de compilation di erentes ou pour nettoyer le dossier :
#param` etres DEBUG= COMPILE=gfortran $(DEBUG) # edition de liens prog : prog.o mod1.o mod2.o <TAB> $(COMPILE) -o prog prog.o mod1.o mod2.o <TAB> @echo compilation termin ee # compilation prog.o : prog.f90 mod1.o mod2.o <TAB> $(COMPILE) -c prog.f90 mod1.o : mod1.f90 mod2.o <TAB> $(COMPILE) -c mod1.f90 mod2.o : mod2.f90 <TAB> $(COMPILE) -c mod2.f90 # destruction des chiers objets et modules detruire : <TAB> rm -f *.o *.mod

87

 di erents appels de make :

make : compilation normale make OPT=-g : compilation en mode debug make OPT=-O2 : compilation optimis e de niveau 2 make detruire : eace les .o et les .mod

Voir [4, 1] pour des d etails. Remarque : pour les petits programmes, le makele peut etre g en er e ` a la main, mais pour les programmes plus longs, il peut etre utile de le g en erer automatiquement, par exemple avec le script perl mkmf , voir : http://www.gfdl.noaa.gov/~vb/mkmf.html

88

Utilisation avanc ee

les concepts pr esent es ici sont plus complexes que les pr ec edents ` a part le concept de pr ecision des r eels, les autres ne sont pas forc ement n ecessaires pour r ealiser des programmes de calcul scientique, sauf peut- etre les pointeurs qui peuvent etre indispensables dans certains cas cependant, ces concepts peuvent permettre de simplier l ecriture des programmes

89

5.1

Types d eriv es

structures de donn ees renfermant plusieurs types di erents exemple : type personne contenant les nom, pr enom, et age dune personne : type personne c h a r a c t e r ( l e n =30) : : nom , prenom i n t e g e r : : age end type personne on peut alors d eclarer des variables de ce type, comme pour nimporte quel type type ( personne ) : : etudiant1 , etudiant2 type ( personne ) , dimension ( 1 : 3 5 ) : : td

90

 les di erentes variables dun type d eriv e sont appel ees champs. On y acc` ede avec le caract` ere %, et on peut utiliser le constructeur de m eme nom que le type pour les initialiser :
etudiant1=personne ( Cesar , J u l e s , 5 7 ) etudiant2=etudiant1 p r i n t , etudiant2 do i =1 ,2 p r i n t , nom , prenom , age read , td ( i )% nom , td ( i )% prenom , td ( i )% age end do p r i n t , td ( 1 )

laectation etudiant2=etudiant1 recopie tous les champs.

91

5.2

Pr ecision des r eels

par d efaut, le type real est dit simple pr ecision, c.-` a-d. cod e sur 4 octets (=32 bits), avec 6 chires signicatifs : ceci est souvent insusant pour faire des calcul scientique pr ecis ; il faut alors utiliser la repr esentation double pr ecision, c.-` a-d. cod ee sur 8 octets (=64 bits), avec 15 chires signicatifs 3 possibilit es : type double precision : double p r e c i s i o n : : x type real avec param` etre kind : i n t e g e r , parameter : : pr=kin d ( 1 . d0 ) r e a l ( pr ) : : x (type r eel de m eme pr ecision que 1. d0, c.-` a-d. double pr ecision) ou
i n t e g e r , p a r a m e t e r : : pr= s e l e c t e d r e a l k i n d ( 1 5 , 3 ) r e a l ( pr ) : : x

(type r eel avec 15 chires signicatifs et exposant a 3 chires, c.-` ` a-d. double pr ecision) la 3e possibilit e est la plus portable (donne la m eme pr ecision quelle que soit la machine)
92

 les valeurs num eriques s ecrivent di eremment selon la pr ecision choisie

valeur 1 4, 32 4, 32 104 real 1. 4.32 4.32e4 double precision 1. d0 4.32d0 4.32d4 real (pr) 1. _pr 4.32_pr 4.32e4_pr

attention ` a la coh erence des types dans les aectations ou op erations : integer : : n double p r e c i s i o n : : u n = 1 u = n ! -- u =1.00000000000000 u = 1 . 2 d0 ! - - u = 1 . 2 0 0 0 0 0 0 0 0 0 0 0 0 0 n = u ! -- n =1 u = 1.2 ! -- u =1.20000004768372 par prudence : ne pas m elanger les entiers et r eels complexes : comme pour les r eels : complex : : z ! --- simple double complex : : z ! --- double pr=kin d ( 1 . d0 ) ! -- ou pr= s e l e c t e d r e a l k i n d ( 1 5 , 3 ) complex ( pr ) : : z ! --- double
p. p.

p.

93

5.3

Fonctions de fonctions

il sagit simplement de cr eer des proc edures dont les arguments peuvent etre dautres proc edures exemple simple : ecrire une fonction integrale qui pour toute fonction f et tout couple de r eels a, b b calcule une approximation de a f (x) dx pour cela : le fonction integrale doit etre mise dans un module, et le type de la fonction f et de ses arguments doivent etre d eclar es dans un bloc interface a lint ` erieur de la fonction integrale attention : dans le programme utilisant la fonction integrale, la fonction f pass ee en argument est : soit une fonction intrins` eque (comme cos, log, exp, sqrt ...), il faut alors la d eclarer avec lattribut intrinsic ; soit d enie dans un module toto, il sut alors de d eclarer lutilisation de ce module (use toto) ; soit d enie dans un sous-programme externe non plac e dans un module, il faut alors la d eclarer avec lattribut external.

94

 exemple :
module m o d _ i n t e g r a l e i m p l i c i t none contains r e a l f u n c t i o n integrale ( f , a , b ) i m p l i c i t none ! --- arguments real , intent ( in ) : : a , b ! --- argument f : bloc interface interface real function f(x) real , intent ( in ) : : x end f u n c t i o n f end i n t e r f a c e ! --- var locales integer : : n , i real : : h n =100 ; h =( ba ) / n integrale =0. do i =0 , n 1 integrale =integrale+h f ( i h ) end do end f u n c t i o n integrale end module m o d _ i n t e g r a l e

95

 utilisation de cette fonction dans un programme :

program p r o g _ i n t e g r a l e us e m o d _ i n t e g r a l e us e mod_creneau i m p l i c i t none real real : : y1 , y2 , intrinsic

: : exp

y1=integrale ( exp , 0 . , 1 . ) y2=integrale ( creneau , 1 . , 1 . ) p r i n t , y1 , y2 end program p r o g _ i n t e g r a l e module mod_creneau i m p l i c i t none contains r e a l f u n c t i o n creneau ( x ) i m p l i c i t none real , intent ( in ) : : x i f ( x < 0 . 0 . and . x > 1 . 0 ) t hen creneau =0. else creneau =1. end i f end f u n c t i o n creneau end module mod_creneau

96

5.4

Interface g en erique

id ee : on veut appliquer une m eme proc edure ` a des arguments de type di erents. Exemple : abs(x) ren voie |x| si x est r eel et a2 + b2 si x = a + ib est complexe. principe : dans un module, on ecrit plusieurs proc edures adapt ees ` a chaque type darguments, et on les regroupe sous un m eme nom g en erique. Cest le compilateur qui d ecide quelle proc edure utiliser selon le type des arguments. exemple : on veut une fonction exponentielle qui renvoie exp(x) si x est r eel, et exp(z ) = exp(a)(cos b+ i sin b) si z = a + ib est complexe

97

module m o d _ e x p o n e n t i e l l e i m p l i c i t none i n t e r f a c e exponentielle module procedure rexp , zexp end i n t e r f a c e contains f u n c t i o n rexp ( x ) r e s u l t ( y ) i m p l i c i t none real , intent ( in ) : : x real : : y y=exp ( x ) end f u n c t i o n rexp f u n c t i o n zexp ( z ) r e s u l t ( y ) i m p l i c i t none complex , i n t e n t ( i n ) : : z complex : : y real : : a , b a= r e a l ( z ) ; b=aimag ( z ) y=cmplx ( cos ( b ) , sin ( b ) ) exp ( a ) end f u n c t i o n zexp end module m o d _ e x p o n e n t i e l l e

m ethode : deux fonctions rexp et zexp stock ees dans le module mod_exponentielle . La fonction g en erique exponentielle est cr e ee avec le bloc interface et ee au tout d ebut linstruction module procedure situ du module.

98

 ensuite, dans un programme principal, on utilise la m eme fonction exponentielle, que largument soit r eel ou complexe : program generique use mod_exponentielle i m p l i c i t none real : : x complex : : z x =0. ; z=cmplx ( 0 . , 3 . 1 4 1 6 ) p r i n t , exp ( x)= , exponentielle ( x ) p r i n t , exp ( z)= , exponentielle ( z ) end program generique

99

5.5

Cr eation de nouveaux op erateurs

exemple : on a une fonction rptens qui avec deux vecteurs r eels v1 et v2 en entr ee renvoie le produit tensoriel w = v1 v2 : w=rptens ( v1 , v2 ) on voudrait utiliser cette fonction sous forme dun op erateur ptens : w=v1 . ptens . v2

100

 on va utiliser un module, un bloc interface operator et linstruction module procedure :

module mod_ptens i m p l i c i t none i n t e r f a c e o p e r a t o r ( . ptens . ) module procedure rptens end i n t e r f a c e contains f u n c t i o n rptens ( v1 , v2 ) r e s u l t ( w ) i m p l i c i t none r e a l , d i m e n s i o n ( : ) , i n t e n t ( i n ) : : v1 , v2 r e a l , d i m e n s i o n ( s i z e ( v1 ) , s i z e ( v2 ) ) : : w integer : : i , j do i =1 , s i z e ( v1 ) do j =1 , s i z e ( v1 ) w ( i , j )= v1 ( i ) v2 ( j ) end do end do end f u n c t i o n rptens end module mod_ptens

les deux points autour de . ptens. sont obligatoires pour d enir un op erateur dans le programme principal utilisant le module mod_ptens, on pourra utiliser lop erateur ptens ainsi : w=v1 . ptens . v2

101

 on peut associer plusieurs fonctions ` a un m eme op erateur (comme avec les interfaces g en eriques, section 5.4) : pour que . ptens. marche aussi avec les complexes, rajouter une fonction zptens dans le module, et ajouter le nom zptens ` a la suite de rptens dans linstruction module procedure on peut aussi vouloir red enir un op erateur existant comme ,+,,/ etc. Cela est possible, mais un peu plus compliqu e (il faut que le nouvel op erateur et lancien di` erent par le type de leurs arguments). Dans lexemple pr ec edent, on ne pourrait pas red enir par lop erateur ptens car est d ej` a d eni pour les tableaux.

102

 exemple de surcharge de + : pour concat ener des cha nes comme lop erateur //, en supprimant des blancs. Remarquer que + garde sa signication pour les autres types.
program surcharge use mod_add_chaine i m p l i c i t none c h a r a c t e r ( l e n =20) : : c1 , c2 , c c1= bon ; c2= j o u r c=c1+c2 print ,c p r i n t , h e l l o da + rling p r i n t ,5+3 end program surcharge

103

module mod_add_chaine i m p l i c i t none i n t e r f a c e o p e r a t o r (+) module procedure add_chaine end i n t e r f a c e contains f u n c t i o n add_chaine ( c1 , c2 ) r e s u l t ( c ) i m p l i c i t none c h a r a c t e r ( l e n = ) , i n t e n t ( i n ) : : c1 , c2 c h a r a c t e r ( l e n = l e n ( c1 )+ l e n ( c2 ) ) : : c c=trim ( adjustl ( c1 ) ) / / trim ( adjustl ( c2 ) ) end f u n c t i o n add_chaine end module mod_add_chaine

104

5.6

Ressources priv ees, publiques, semipriv ees

quand un programme utilise un module, il a acc` es a toutes les variables du module, et tous ses sous` programmes. Cela peut parfois provoquer des conits avec les propres variables du programme si les noms sont identiques exemple : un programmeur veut utiliser un module servant ` a calculer des normes de matrices avec la fonction norme pour son programme. Ce module contient beaucoup dautres fonctions auxiliaires utilis ees par la fonction norme. Le programmeur ne conna t pas ces autres fonctions (il na acc` es quau chier objet par exemple). Dans ce cas, les fonctions auxiliaires ne devraient pas etre visibles ` a lext erieur du module, car sinon, lutilisateur naurait par exemple pas le droit de cr eer des fonctions portant le m eme nom, alors quil ignore leur existence ! on peut alors utiliser les fonctions private (priv e), public et les attributs correspondants private et public pour limiter lacc` es a ` certaines variables depuis lext erieur du module voir la r ef erence [3] pour plus de d etails.
105

5.7

Pointeurs

la structure de pointeur est fondamentale en langage C et C++. En fortran 90, une structure similaire existe, mais nest pas dun int er et evident pour le calcul scientique dans la norme fortran 95, elle etait indispensable pour d enir des tableaux allouables ` a lint erieur de types d eriv es (comme par exemple pour d enir des tableaux de tableaux). Mais depuis la norme fortran 2000, cela nest plus n ecessaire. la notion de pointeur en fortran 90 ne sera donc pas etudi ee plus en d etail dans ce cours

106

R ef erences
[1] MANUELS GNU. manual make. http ://www.gnu.org/software/make/manual/make.html. [2] MANUELS GNU. Manuel de ddd, interface graphique de debugger. http://www.gnu.org/s/ddd/manual/html_mono/ddd.html. [3] IDRIS. Cours IDRIS Fortran, 2004. http ://www.idris.fr/data/cours/lang/f90/F90 cours.html. [4] Luc Mieussens. Cours unix-shell-makele. Institut de Math ematiques - Universit e de Bordeaux, 2004. http ://www.math.u-bordeaux1.fr/ mieussen/PAGE WEB/ENSEIGNEMENT/unix shell.pdf. [5] Luc Mieussens. Petit guide pour Emacs. Institut de Math ematiques - Universit e de Bordeaux, 2004. http ://www.math.u-bordeaux1.fr/ mieussen/PAGE WEB/ENSEIGNEMENT/ guide emacs version 140904.pdf.

107

Liste de quelques fonctions intrins` eques usuelles en Fortran 90

adapt e des cours de lIDRIS, disponibles sur http ://www.idris.Fr/data/cours/lang/f90/F90 cours.html

On donne la signication de la commande, puis, dans un exemple, la syntaxe ` a utiliser, suivie apr` es le signe de la valeur retourn ee en sortie.

Fonctions intrins` eques sur les entiers, r eels, complexes, extensibles aux tableaux
ABS : retourne la valeur absolue de son argument. Pour un complexe, retourne sa norme : x2 + y 2 . ABS ( 1) 1 ABS ( 1.5) 1 . 5 ; ABS ( ( 3 . , 4 . ) ) ACOS ( 0 . 5 4 0 3 0 2 3 1 ) AIMAG ( ( 2 . , 3 . ) ) AINT ( 2 . 7 8 3 ) 1.0 5.0

ACOS : retourne larc cosinus en radians de son argument r eel. AIMAG : retourne la partie imaginaire du complexe pass e en argument. 3.0 2.0 AINT : tronque le r eel pass e en argument 2 . 0 ; AINT ( 2.783) ANINT : retourne, sous forme dun r eel, lentier le plus proche du r eel transmis. ANINT ( 2 . 7 8 3 ) 3 . 0 ANINT ( 2.783) 3.0 ASIN : retourne larc sinus en radians de son argument r eel. ASIN ( 0 . 8 4 1 4 7 0 9 8 ) ATAN ( 1 . 5 5 7 4 0 7 7 ) CEILING ( 3 . 7 ) 4 CEILING ( 3.7) 3 CMPLX : retourne un complexe dont les parties r eelle et imaginaire sont transmises en argument. CMPLX ( 3.) 3.0+0. i ; CMPLX ( 2 , 4 . ) 3.0 4.0 i 2.0+4.0i CONJG : retourne le complexe conjugu e de celui pass e en argument. CONJG ( ( 3 . 0 , 4 . 0 ) ) COS ( 1 . 0 ) COS : retourne le cosinus de langle pass e en argument (exprim e en radians). 0.54030231 108 1.0 1.0 ATAN : retourne larc tangente en radians de son argument r eel. CEILING : retourne lentier imm ediatement sup erieur au r eel transmis en argument.

 COSH : retourne le cosinus hyperbolique. COSH ( 1 . 0 ) 1.5430806 DBLE : convertit en double pr ecision largument transmis. EXP : retourne lexponentiel de largument transmis. EXP ( 1 . 0 ) 2.7182818 FLOOR : retourne lentier imm ediatement inf erieur au r eel transmis en argument. FLOOR ( 3 . 7 ) 3 ; FLOOR ( 3.7) 4 INT : convertit en entier largument transmis. INT ( 3.7) 3 INT ( 9 . 1 / 4 . 0 ) 2 LOG : retourne le logarithme n ep erien de largument transmis. LOG ( 2 . 7 1 8 2 8 1 8 ) 1 . 0 LOG ( 1 0 . 0 ) 2 . 3 0 2 5 8 5 1 LOG10 : retourne le logarithme d ecimal de largument transmis. LOG10 ( 1 0 . 0 ) 1 . 0 LOG10 ( 1 0 . E10 ) 1 1 . 0 MAX : retourne le maximum des nombres pass es en argument. MAX ( 9 . 0 , 7 . 0 , 2 . 0 ) MIN ( 9 . 0 , 7 . 0 , 2 . 0 ) MOD ( 3 . 0 , 2 . 0 ) 1 . 0 MOD ( 8 ,5) 3 REAL : convertit en r eel largument transmis. REAL ( 3 ) 3.0 SIGN : retourne le nombre dont la valeur absolue est celle du premier argument et le signe celui du deuxi` eme. SIGN ( 3 . 0 , 2 . 0 ) SIN ( 1 . 0 ) SINH ( 1 . 0 ) SQRT ( 5 . 0 ) TAN ( 1 . 0 ) TANH ( 1 . 0 ) 3.0 SIN : retourne le sinus de langle pass e en argument (exprim e en radians). 0.84147098 1.1752012 2.236068010 1.5574077 0.76159416 109 SINH : retourne le sinus hyperbolique. SQRT : retourne la racine carr e de son argument. TAN : retourne la tangente de langle pass e en argument (exprim e en radians). TANH : retourne la tangente hyperbolique. 7.0 9.0 MIN : retourne le minimum des nombres pass es en argument. MOD : retourne le reste de la division eectu ee ` a laide des deux arguments fournis.

Fonctions intrins` eques pour le temps de calcul

eel t le temps CPU en secondes (ou r eel < 0 CPU TIME(t) (Norme 95) retourne dans le r si indisponible). Par di erence entre deux appels, il permet d evaluer la consommation CPU dune section de code. call cpu_time ( t1 ) ... call cpu_time ( t2 ) print , temps CPU = , t2t1

Fonctions intrins` eques pour les cha nes de caract` eres

ADJUSTL : cadre ` a gauche la cha ne pass ee en argument : supprime les blancs en t ete ; compl` ete ` a droite par des blancs. ADJUSTL ( Fortran ) Fortran ADJUSTR : cadre ` a droite la cha ne pass ee en argument : supprime les blancs en n ; compl` ete ` a gauche par des blancs. ADJUSTR ( F o r t r a n ) Fortran LEN : retourne la longueur de la cha ne de caract` eres transmise en argument. CHARACTER ( len =10) CH ; LEN ( CH ) 10 LEN TRIM : retourne la longueur de la cha ne de caract` eres transmise en argument sans consid erer les blancs de n. LEN_TRIM ( LEN_TRIM ( FORTRAN ) 0 ) 9

LGE : compare les deux cha nes de caract` eres transmises en argument : retourne .true. si la premi` ere cha ne est sup erieure ou egale ` a la deuxi` eme, .false. sinon. LGE ( MANET , MONET ) . false . LGE ( MANET Edouard , MANET ) . true . LGT : compare les deux cha nes de caract` eres transmises en argument : retourne .true. si la premi` ere cha ne est sup erieure strictement ` a la deuxi` eme, .false. sinon. LGT ( MANET , MANET ) . false . LLE : compare les deux cha nes de caract` eres transmises en argument : retourne .true. si la premi` ere cha ne est inf erieure ou egale ` a la deuxi` eme, .false. sinon. LLE ( MANET , MONET ) LLE ( MANET , MANET ) . true . . true .

LLT : compare les deux cha nes de caract` eres transmises en argument : retourne .true. si la premi` ere cha ne est inf erieure strictement ` a la deuxi` eme, .false. sinon. LLT ( MANET , MANET ) TRIM ( PICASSO bon // j o u r ) . false . PICASSO TRIM : retourne la cha ne de caract` eres transmise d ebarrass ee de ses blancs de n. // : op erateur pour concat ener deux cha nes. bo nj o ur 110

4
4.1

Fonctions et subroutines intrins` eques tableaux

interrogation
SIZE(array[,dim]) retourne la taille (ou l etendue de la dimension indiqu ee via dim) du tableau pass e en argument. integer , dimension ( 2 : 2 7 , 0 : 4 9 ) : : t SIZE ( t ) 1500 SIZE ( t , dim =1) 30 MAXLOC(tab) et MINLOC(tab) retournent, pour le tableau tab, lemplacement de l el ement maximum/minimum (si le tableau est multidimensionel, le r esultat est un vecteur dont les el ements sont les indices de l el ement dans tab) integer , dimension ( 2 : 2 7 , 0 : 4 9 ) : : t integer , dimension ( 1 : 2 ) : : ind_elem_max , ind_elem_min ind_elem_max=maxloc ( t ) ind_elem_min=minloc ( t )

4.2

R eduction

Selon que DIM est absent ou pr esent, toutes ces fonctions retournent soit un scalaire soit un tableau de rang n-1 en d esignant par n le rang du tableau pass e en premier argument. La plupart de ces expressions acceptent un masque en param` etre, qui permet de nappliquer les fonctions qu` a certains el ements (voir le cours de lIDRIS de Fortran 95) COUNT(verif) : verif est une expression logique sur deux tableaux conformes, count compte le nombre de fois o` u cette expression est v eri ee par deux el ements Soit | 1 A | | 2 3 4 5 | | 6 |

D e compte global des valeurs de A > 2 : COUNT ( A > 3) 4 MAXVAL(array) et MINVAL(array) | 1 3 5 | Soit A | | | 2 4 6 | maxval ( A ) 6 minval ( A ) 1 PRODUCT(tab) renvoie le produit de tous les el ements du tableau tab. PRODUCT ( ( / 2 ,5 , 6 / ) ) 60 SUM(tab) renvoie la somme de tous les el ements du tableau tab. SUM ( ( / 2 ,5 , 6 / ) ) 1

4.3

multiplication

DOT PRODUCT(vector a,vector b) retourne le produit scalaire des deux vecteurs pass es en argument (produit hermitien si vector a est complexe)

111

v1 =(/ 2, 3, 1 / ) ; v2 =(/ 6 , 3 , 3 / ) DOT_PRODUCT ( v1 , v2 ) 0 MATMUL(matrix a,matrix b) eectue le produit matriciel de deux matrices ou dune matrice 3 6 1 2 et dun vecteur pass es en argument. Soit la matrice A = 2 3 1 et le vecteur v = 4
1 2 4 1

MATMUL ( A , V ) v=
29 7 10

4.4

transformation

TRANSPOSE(mat) renvoie la transpos ee de la matrice mat (tableau bidimensionnel)

112