IDRIS Fortran Cours

COURS FORTRAN
Langage Fortran
Support de cours
Patrick Corde Anne Fouilloux

Messagerie : Prenom.Nom@idris.fr
INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE
Cours langage Fortran 11 mars 2010

Patrick Corde et Anne Fouilloux
Liste des transparents

1 Introduction . . . . . . . . . . . . . . . . 1.1 Historique . . . . . . . . . . . . . . . . 1.2 bibliographie . . . . . . . . . . . . . . . 1.3 documentation . . . . . . . . . . . . . . e e e 2 Gnralits . . . . . . . . . . . . . . . . . 2.1 Bases de numration . . . . . . . . . . . e
e e 2.2 Reprsentation des donnes . . . . . . . e 2.2.1 Reprsentation des entiers . . . . . . e e 2.2.2 Reprsentation des rels . . . . . . . e 2.2.3 Reprsentation des complexes
2 8 9 12 15 17 18 20 20 21 23 24 25 28 29 30 30 32 33 34
. . . .
e 2.2.4 Reprsentation des logiques . . . . . .
2.2.5 Reprsentation des caract`res . . . . . e e

e 2.3 Jeu de caract`res . . . . . . . . . . . . . e 2.4 Notion dunit de programme . . . . . . e 2.5 Elments syntaxiques
. . . . . . . . . .
2.5.1 Format libre
. . . . . . . . . . . . .
2.5.2 Commentaires . . . . . . . . . . . . . 3 Dclarations . . . . . . . . . . . . . . . . e 3.1 Identicateurs . . . . . . . . . . . . . .



3.2 Dirents types . . . . . . . . . . . . . . e 3.3 Syntaxe . . . . . . . . . . . . . . . . . .
e e e 3.3.1 Forme gnrale dune dclaration
3 35 37 37
. .
3.3.2 Cas particulier : le type CHARACTER 38 3.4 Instruction IMPLICIT NONE . . . . . . 3.5 Constantes littrales . . . . . . . . . . . e
e 3.5.1 Constantes enti`res . . . . . . . . . .
39 40 40 41 42 43 44 45 45 47 48 49 52 53
3.5.2 Constantes relles simple prcision . . e e

e e 3.5.3 Constantes relles double prcision . .
3.5.4 Constantes complexes . . . . . . . . .

nes e 3.5.5 Constantes cha de caract`res . . .
3.6 Initialisation . . . . . . . . . . . . . . . 3.6.1 Linstruction DATA . . . . . . . . . . 3.6.2 Le symbole = . . . . . . . . . . . . 3.7 Constantes symboliques . . . . . . . . . 3.8 Instruction EQUIVALENCE . . . . . . . e 4 Oprateurs et expressions . . . . . . . . .
e e 4.1 Oprateurs arithmtiques . . . . . . . .


4.1.1 Les oprateurs . . . . . . . . . . . . e 4.1.2 Les expressions . . . . . . . . . . . . 4.1.3 Conversion implicite . . . . . . . . . 4.2 Oprateurs relationnels . . . . . . . . . . e 4.3 Oprateurs logiques . . . . . . . . . . . e 4.3.1 Les tables de vrit . . . . . . . . . . e e 4.4 Oprateur de concatnation . . . . . . . e e
e 4.5 Oprateur daectation . . . . . . . . . .
4 53 54 56 58 59 60 61 62 62 62 64 66 67 67 69 71 71 72 79
4.5.1 syntaxe gnrale . . . . . . . . . . . e e 4.5.2 R`gles de typage . . . . . . . . . . . e

e e 4.6 Priorit des Oprateurs
. . . . . . . . .
5 Structures de contrle . . . . . . . . . . . o 5.1 Les tests . . . . . . . . . . . . . . . . . 5.1.1 Le bloc IF . . . . . . . . . . . . . . . 5.1.2 Le bloc SELECT-CASE . . . . . . . 5.2 Les itrations . . . . . . . . . . . . . . . e 5.2.1 Linstruction GOTO . . . . . . . . . 5.2.2 Les bloucles DO . . . . . . . . . . . 6 Tableaux . . . . . . . . . . . . . . . . . .


6.1 Dclaration . . . . . . . . . . . . . . . . e 6.2 Dnitions (rang, prol, tendue) . . . . e e 6.3 Initialisation . . . . . . . . . . . . . . . 6.3.1 Le symbole = . . . . . . . . . . . . 6.3.2 Le constructeur de vecteurs . . . . . . 6.3.3 Linstruction DATA . . . . . . . . . . 6.4 Manipulation de tableaux . . . . . . . . 6.4.1 Expressions de type tableau . . . . . 6.4.2 Sections de tableaux . . . . . . . . . 7 Entres-Sorties . . . . . . . . . . . . . . . e 7.1 Introduction . . . . . . . . . . . . . . . 7.2 Acc`s squentiel . . . . . . . . . . . . . e e
e 7.2.1 Fichier binaire squentiel . . . . . . .
5 80 82 85 85 86 88 89 89 90 93 94 96 97 99
7.2.2 Fichier texte squentiel . . . . . . . . e
e 7.3 Acc`s direct . . . . . . . . . . . . . . . 136
7.3.1 Fichier binaire ` acc`s direct . . . . . 137 a e

a e 7.3.2 Fichier texte ` acc`s direct . . . . . . 139
7.4 Fichier temporaire . . . . . . . . . . . . 145



7.5 Destruction dun chier . . . . . . . . . 146 7.6 Fichier interne . . . . . . . . . . . . . . 147 7.7 Instructions de positionnement . . . . . . 150 7.8 Instruction INQUIRE . . . . . . . . . . 153 7.9 Remarques . . . . . . . . . . . . . . . . 155 e 8 Procdures . . . . . . . . . . . . . . . . . 162 8.1 Arguments . . . . . . . . . . . . . . . . 163 8.2 Subroutines . . . . . . . . . . . . . . . . 165 8.3 Fonctions . . . . . . . . . . . . . . . . . 166 8.4 Arguments de type cha de caract`res . 168 ne e 8.5 Arguments de type tableau . . . . . . . . 170 8.6 Arguments de type procdure . . . . . . 173 e 8.7 Procdures internes e . . . . . . . . . . . 175 8.8 Dure de vie et visibilit des identicateurs 178 e e 8.9 Procdures intrins`ques . . . . . . . . . 180 e e 9 Common . . . . . . . . . . . . . . . . . . 181 9.1 Linstruction COMMON . . . . . . . . . 182 9.2 Common blanc . . . . . . . . . . . . . . 183
e e 9.3 Common tiquet . . . . . . . . . . . . 185

9.3.1 Initialisation : BLOCK DATA . . . . 186 9.3.2 Instruction SAVE et COMMON . . . 188
e 9.4 R`gles et restrictions . . . . . . . . . . . 190
10 Include . . . . . . . . . . . . . . . . . . . 193 10.1 La directive INCLUDE . . . . . . . . . 194 11 Annexe A : entres-sorties - syntaxes . . . . 196 e
e e 12 Annexe B : procdures intrins`ques . . . . 214
13 Annexe C : aspects obsol`tes . . . . . . . . 226 e

e 14 Annexe D : syst`me de compilation . . . . 230
15 Annexe E : exercices . . . . . . . . . . . . 234

plan
1 Introduction
1.1 Historique 1.2 Bibliographie 1.3 Documentation

Historique
1.1
Historique
Code machine (notation numrique en octal). e Assembleurs de codes mnmoniques. e 1954Projet cration du premier langage e symbolique par John Backus dIBM = FORTRAN (Mathematical FORmula TRANslating System) : Ecacit du code gnr (performance). e e ee Langage quasi naturel pour scientiques (productivit, maintenance, lisibilit). e e 1957Livraison des premiers compilateurs. 1958Fortran II (IBM) = sous-programmes compilables de faon indpendante. c e

Historique
10
Gnralisation aux autres constructeurs mais : e e divergences des extensions = ncessit de e e normalisation, ASA American Standards Association (= ANSI American Nat. Standards Institute). Comit e charg du dveloppement dune norme Fortran e e = 1966. 1966Fortran IV (Fortran 66). Evolution par extensions divergentes. . . 1977Fortran V (Fortran 77). Quasi compatible : aucune itration des boucles nulles (DO I=1,0) e Nouveauts principales : e type caract`re, e IF-THEN-ELSE, E/S acc`s direct et OPEN. e

Historique
11
Travail des comits X3J3/ANSI et WG5/ISO pour e moderniser Fortran 77 : Standardisation : inclusion dextensions. Dveloppement : nouveaux concepts dj` exe ea ploits par langages plus rcents APL, Algol, e e PASCAL, Ada, . . . Performances en calcul scientique Totalement compatible avec Fortran 77 1991/1992Norme ISO et ANSI = Fortran 90 1994 Premiers compilateurs Fortran 90 Cray et IBM 1997 Norme ISO et ANSI = Fortran 95 1999 Premiers compilateurs Fortran 95 sur Cray T3E puis IBM RS/6000 septembre 2004 Norme ISO et ANSI = Fortran 2003.

bibliographie
12
1.2
bibliographie
Adams, Brainerd, Hendrickson, Maine, Martin, Smith, The Fortran 2003 Handbook, Springer, 2009, (712 pages), ISBN 978-1-84628-378-9. Adams, Brainerd, Martin, Smith et Wagener, Fortran 95 Handbook, MIT Press, 1997, (711 pages), ISBN 0-262-51096-0, Brainerd, Goldberg, Adams, Programmers guide to Fortran 90, 3edit. Unicomp, 1996, e (408 pages), ISBN 0-07-000248-7, Chamberland Luc, Fortran 90 : A Reference Guide, Prentice Hall, ISBN 0-13-397332-8, Delannoy Claude, Programmer en Fortran 90 Guide complet, Eyrolles, 1997, (413 pages), ISBN 2-212-08982-1, Dubesset M., Vignes J., Les spcicits du e e Fortran 90, Editions Technip, 1993, (400 pages), ISBN 2-7108-0652-5, Ellis, Phillips, Lahey, Fortran 90 Programming, Addisson-Wesley, 1994, (825 pages), ISBN 0-201-54446-6,

bibliographie
13
Hahn B.D., Fortran 90 for the Scientist & Engineers, Edward Arnold, London, 1994, (360 pages), ISBN 0-340-60034-9, Kerrigan James F., Migrating to Fortran 90, OReilly & Associates Inc., 1994, (389 pages), ISBN 1-56592-049-X, Lignelet P., Fortran 90 : approche par la pratique, Editions Studio Image (srie informatique), 1993, e ISBN 2-909615-01-4, Lignelet P., Manuel complet du langage Fortran 90 et Fortran 95, calcul intensif et gnie e logiciel, Col. Mesures physiques,Masson, 1996, (320 pages), ISBN 2-225-85229-4, Lignelet P., Structures de donnes et leurs e algorithmes avec Fortran 90 et Fortran 95, Masson, 1996, (360 pages), ISBN 2-225-85373-8, Morgan and Schoenfelder, Programming in Fortran 90, Alfred Waller Ltd., 1993, ISBN 1-872474-06-3,

bibliographie
14
Metcalf M., Reid J., Fortran 90 explained, Science Publications, Oxford, 1994, (294 pages), ISBN 0-19-853772-7, Traduction franaise par Pichon B. et Caillat c M., Fortran 90 : les concepts fondamentaux, Editions AFNOR, 1993, ISBN 2-12-486513-7, Fortran 90/95 explained, Oxford University Press, 1996, (345 pages), ISBN 0-19-851888-9, Fortran 95/2003 explained, Oxford University Press, 2004, (416 pages), ISBN 0-19-852693-8, Olagnon Michel, Traitement de donnes nume e riques avec Fortran 90, Masson, 1996, (364 pages), ISBN 2-225-85259-6, Redwine Cooper, Upgrading to Fortran 90, Springer, 1995, ISBN 0-387-97995-6, International Standard ISO/IEC 1539-1 :1997(E) Information technology - Progr. languages - Fortran - Part1 : Base language. Disponible aupr`s de e lAFNOR.
documentation
15
1.3
documentation
Documentation IBM/SP6 : XL Fortran Language Reference XL Fortran USERs Guide ESSL - Engineering and Scientific Subroutine Library Guide Disponibles sur le serveur Web IDRIS ` ladresse a
http ://www.idris.fr/su/Scalaire/vargas/doc-ibm.html
Documentation IDRIS IBM/SP6 : descriptif matriel et logiciel, e supports de cours, FAQ, Disponibles sur le serveur Web IDRIS ` ladresse a
http ://www.idris.fr/su/Scalaire/vargas
Documentation NEC SX-8 Fortran 90/SX Language Reference Manual Fortran 90/SX Programmers Guide Fortran 90/SX Fortran 2003 Features Disponibles sur le serveur Web IDRIS ` ladresse a http ://www.idris.fr/users/doc nec-sx8. (Acc`s e toutefois limit aux utilisateurs de lIDRIS). e
documentation
16
Documentation IDRIS NEC SX-8 descriptif matriel et logiciel, e supports de cours, FAQ, Disponibles sur le serveur Web IDRIS ` ladresse a
http ://www.idris.fr/su/Vectoriel/brodie
Documentation gnrale e e Supports de cours Fortran 95 IDRIS :

www.idris.fr/data/cours/lang/fortran/choix_doc.html
Manuel Fortran 77 pour dbutants (en anglais) : e

www.idris.fr/data/cours/lang/fortran/choix_doc.html
Fortran Market Index :

www.swcp.com/~walt/

plan
17
2 Gnralits e e e
2.1 Bases de numration e 2.2 Reprsentation des donnes e e 2.2.1 Reprsentation des entiers e 2.2.2 Reprsentation des rels e e 2.2.3 Reprsentation des complexes e 2.2.4 Reprsentation des logiques e 2.2.5 Reprsentation des caract`res e e 2.3 Jeu de caract`res e 2.4 Notion dunit de programme e e 2.5 Elments syntaxiques 2.5.1 Format libre 2.5.2 Commentaires

Bases de numration e
18
2.1
Soit un nombre n dont lcriture en base b est de la e forme : (up up1 ....u1 u0 )b avec : i {0, 1, ..., p} 0 ui < b La valeur du nombre n en base 10 est :
p
n10 =
i=0
u i bi
Les ordinateurs ne savent calculer quen base 2, de ce fait les donnes stockes dans la mmoire le sont e e e sous la forme dune suite de chires binaires 0 et 1 appels bits abrviation de binary digits. Un ensemble e e de 8 bits sappelle un octet. Lcriture des donnes en base 2 se rv`le fastidieuse. e e e e Par commodit, on adopte plutt la base 8 (base octale) e o ou la base 16 (hexadcimale) pour les dnir. e e
19
Lcriture dun nombre en octal seectuera ` laide e a des chires de 0 ` 7. a Lcriture dun nombre en hexadcimal seectuera e e a ` laide des chires de 0 ` 9 auxquels on ajoute les a lettres de a ` f. a Supposons que lon dispose de lcriture dun nombre e en base 2. Sa conversion en octal peut tre faite en e dcoupant le motif binaire par tranches de 3 bits en e partant de la droite, puis en convertissant en base 10 chaque groupe obtenu. Sa conversion en hexadcimal pourra seectuer de e la mme mani`re ` laide dun dcoupage par tranches e e a e de 4 bits.
Exemple
10011101012 = = 10011101012 = 10011101012 = 1*20 + 1*22 + 1*24 + 1*25 + 1*26 + 1*29 62910 1|001|110|1012 = 11658 10|0111|01012 = 27516

Reprsentation des donnes e e
20
2.2
Reprsentation des donnes e e Reprsentation des entiers e
2.2.1
Dans la mmoire de lordinateur, les donnes e e numriques sont reprsentes ` laide dun motif e e e a binaire de longueur 32, 64 voire 128 bits. La reprsentation en machine dun nombre entier e positif correspond ` son criture en base 2. Pour a e lobtenir, il sut de procder ` des divisions successives e a par 2. Les nombres entiers ngatifs sont reprsents en e e e complment vrai ou complment ` 2 qui consiste, e e a a ` partir du motif binaire du nombre positif, ` inverser a tous les bits puis dajouter 1. De ce fait, sur n bits, les nombres reprsentables e sont : -2n1 i 2n1 -1
Exemple +510 -510 -510 -510 = = = = 000000000000000000000000000001012 111111111111111111111111111110102 + 1 111111111111111111111111111110112 FFFFFFFB16

Reprsentation des rels e e
21
2.2.2
Un nombre rel ou ottant est caractris par : e e e son signe, son exposant ou caractristique, e sa mantisse. Son mode de reprsentation est un motif binaire e respectant la norme IEEE. Reprsentation dun nombre rel sur 32 bits. e e Ce type de rel, appel rel simple prcision, admet e e e e un motif binaire de la forme : seeeeeeeemm s : bit de signe, e : exposant sur 8 bits ` excdent 127, a e m : mantisse sur 23 bits. Le nombre reprsent correspond ` : e e a r = s1.m*2e127
22
Ce type de reprsentation permet de reprsenter les e e nombres : 1.2*1038 |r| 3.4*10+38 avec 6 chires signicatifs. Reprsentation dun nombre rel sur 64 bits. e e Ce type de rel, appel rel double prcision, admet e e e e un motif binaire de la forme : seeeeeeeeeeemm s : bit de signe, e : exposant sur 11 bits ` excdent 1023, a e m : mantisse sur 52 bits. Le nombre reprsent correspond ` : e e a r = s1.m*2e1023 Ce type de reprsentation permet de reprsenter les e e nombres : 2.2*10308 |r| 1.8*10+308 avec 15 chires signicatifs.

Reprsentation des complexes e
23
2.2.3
Reprsentation des complexes e
Un nombre complexe est une paire de nombres rels, e simple ou double prcision, correspondant aux parties e relle et imaginaire. e
Exemple
Soit le nombre complexe 1.5 -1.5i Sa reprsentation en simple prcision ncessite 2 e e e rels sur 32 bits : e
0 01111111 1000...0002 = 3FC0000016 = +1.510 1 01111111 1000...0002 = BFC0000016 = -1.510

Reprsentation des logiques e
24
2.2.4
Reprsentation des logiques e
Un logique est une entit qui peut prendre comme e valeur : .TRUE. .FALSE. Il est reprsent en gnral sur 32 bits (4 octets). Il e e e e peut exister des variantes codes sur 1, 2 voire 8 octets. e Tous les bits sont positionns ` 0 sauf le bit le plus ` e a a droite qui pour la valeur .TRUE. est positionn ` 1. ea

Reprsentation des caract`res e e
25
2.2.5
Un caract`re est cod sur 1 octet. Sa reprsentation e e e interne respecte un codage appel codage ASCII. e Il existe 128 caract`res dirents dont les reprsene e e tations sont indiques dans une table dite table ASCII. e Dans cette table les caract`res numriques ainsi que e e les caract`res alphabtiques (majuscules et minuscules) e e sont rangs conscutivement et en ordre croissant. e e On appelle cha de caract`res une suite de ne e caract`res rangs de faon conscutive en mmoire. e e c e e

26
Tab. 1
Caract. C-@ (NUL) C-a (SOH) C-b (STX) C-c (ETX) C-d (EOT) C-e (ENQ) C-f (ACK) C-g (BEL) C-h (BS) C-i (HT) C-j (LF) C-k (VT) C-l (FF) C-m (CR) C-n (SO) C-o (SI) C-p (DLE) C-q (DC1) C-r (DC2) C-s (DC3) C-t (DC4) C-u (NAK) C-v (SYN) C-w (ETB) C-x (CAN) C-y (EM) C-z (SUB) C-[ (ESC) C-\ (FS) C-] (GS) C-$ (RS) C- (US) dc. e 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
table des codes ASCII des caract`res e

oct. 000 001 002 003 004 005 006 007 010 011 012 013 014 015 016 017 020 021 022 023 024 025 026 027 030 031 032 033 034 035 036 037 Caract. espace ! " # $ % & ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? dc. e 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 hex 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f oct. 040 041 042 043 044 045 046 047 050 051 052 053 054 055 056 057 060 061 062 063 064 065 066 067 070 071 072 073 074 075 076 077
hex 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f

27
Caract. @ 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 [ \ ] ^ _
dc. e 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
oct. 100 101 102 103 104 105 106 107 110 111 112 113 114 115 116 117 120 121 122 123 124 125 126 127 130 131 132 133 134 135 136 137
Caract. 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 { | } C- ?
dc. e 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
oct. 140 141 142 143 144 145 146 147 150 151 152 153 154 155 156 157 160 161 162 163 164 165 166 167 170 171 172 173 174 175 176 177

Jeu de caract`res e
28
2.3
Jeu de caract`res e
26 lettres de lalphabet, chires 0 ` 9, a caract`res spciaux : e e ! ( % ? le caract`re espace, e le caract`re e Remarque : les caract`res minuscules sont convertis en majuse cules par le compilateur. (underscore). * = / + > . " ) : & < ; , $

Notion dunit de programme e
29
2.4
Notion dunit de programme e
Un programme source Fortran est compos de e parties indpendantes appeles units de programme e e e (scoping unit). Chaque partie est compile de faon indpendante. e c e Chacune admet son propre environnement. Il sera cependant possible que ces parties communiquent entre elles. Les direntes units de programme sont : e e le programme principal, les sous-programmes : de type subroutine, de type function, les modules, les block data. Chaque unit comprend une partie dclarative e e (dclaration des variables locales, ...) suivie dune partie e comportant des instructions excutables ; linstruction e STOP interrompt le programme.

Elments syntaxiques e
30
2.5
e Elments syntaxiques Format libre
2.5.1
Dans le mode format libre les lignes peuvent tre de longueur quelconque ` concurrence de 132 e a caract`res. e Il est galement possible de coder plusieurs inse tructions sur une mme ligne en les sparant avec le e e caract`re ; . e
Exemple
print *, Entrez une valeur :; read *,n
Une instruction peut tre code sur plusieurs lignes : e e on utilisera alors le caract`re & . e
Exemple
print *, Montant HT :, montant_ht, TVA :, tva , Montant TTC :, montant_ttc & &

31
Lors de la coupure dune cha de caract`res la ne e suite de la cha doit obligatoirement tre prcde du ne e e e e caract`re & . e
Exemple
print *, Entrez un nombre entier & &compris entre 100 & 199
Remarque : il existe aussi le Format xe , considr ee maintenant comme obsol`te dont la structure dune e ligne est : zone tiquette (colonnes 1 ` 5) e a zone instruction (colonnes 7 ` 72) a colonne suite (colonne 6)

32
2.5.2
Commentaires
Le caract`re ! rencontr sur une ligne indique que e e ce qui suit est un commentaire. On peut videmment e crire une ligne compl`te de commentaires : il sut e e pour cela que le 1er caract`re non blanc soit le caract`re e e !
Exemple
if (n < 100 .or. n > 199) ! Test cas derreur . . . . ! On lit lexposant read *,x ! On lit la base read *,y if (y <= 0) then ! Test cas derreur print *, La base doit etre un nombre >0 ^ else z = y**x ! On calcule la puissance end if
Remarque : en format xe, les lignes qui commencent par C, c, * ou ! en colonne 1 sont des commentaires.

Plan
33
3 Dclarations e
3.1 Identicateurs 3.2 Dirents types e 3.3 Syntaxe 3.4 Instruction IMPLICIT NONE 3.5 Constantes littrales e 3.6 Initialisation 3.7 Constantes symboliques 3.8 Instruction EQUIVALENCE

Identicateurs
34
3.1
Identicateurs
Un identicateur permet de donner un nom ` : a une variable, une constante, une procdure. e Il est dni par : e une suite de caract`res alphanumriques (lettres non e e accentues, chires, underscore), e le premier caract`re doit tre une lettre, e e la longueur est limite ` 31 caract`res, e a e on ne distingue pas les lettres majuscules des minuscules. Exemples didenticateurs
compteur Compteur fin_de_fichier montant_annee_1993

Dirents types e
35
3.2
Dirents types e
Le type dune variable dtermine : e le nombre doctets ` rserver en mmoire, a e e un mode de reprsentation interne, e lensemble des valeurs admissibles, lensemble des oprateurs qui peuvent lui tre appliqus. e e e

Dirents types e
36
Types prdnis ou de bases e e INTEGER CHARACTER LOGICAL REAL DOUBLE PRECISION COMPLEX : entier : caract`re e : deux valeurs
.TRUE. / .FALSE.
: rel simple prcision e e : rel double prcision e e : complexe simple prcision e
Remarque : la prcision dun rel simple est de 7 chires e e dcimaux signicatifs alors que celle dun double est de 15. e Attributs Chaque type peut tre surcharg des attributs suivants : e e PARAMETER DIMENSION SAVE EXTERNAL INTRINSIC : constante symbolique : taille dun tableau : objet statique : procdure externe e : procdure intrins`que e e

Syntaxe
37
3.3 3.3.1
Syntaxe
Forme gnrale dune dclaration e e e
type[, liste attributs :: ] liste identificateurs
Exemple
PROGRAM declaration INTEGER , SAVE :: compteur INTEGER :: temperature LOGICAL :: arret_boucle ... END PROGRAM declaration
PROGRAM declaration INTEGER SAVE ... END PROGRAM declaration
indice_boucle indice_boucle

Syntaxe
38
3.3.2
Cas particulier : le type CHARACTER
Pour dclarer une cha de caract`res on prcise de e ne e e plus sa longueur. Si elle nest pas indique elle est gale ` e e a 1: CHARACTER(LEN=N) ch_car CHARACTER c Lancienne syntaxe suivante est toujours disponible mais dclare obsol`te : e e e CHARACTER*N ch_car
Exemple
PROGRAM declaration CHARACTER(LEN=11) chaine1 CHARACTER*11 chaine2 ... END PROGRAM declaration

Instruction IMPLICIT NONE
39
3.4
Instruction IMPLICIT NONE
Par dfaut, les variables dont lidenticateur commence e par les caract`res I ` N sont de type INTEGER. e a Toutes les autres sont de type REAL. Linstruction IMPLICIT NONE change cette r`gle car elle e impose ` lutilisateur la dclaration de chaque variable. a e elle permet la dtection dun certain nombre derreurs e ` la compilation. a Cette instruction est vivement recommande ! ! ! e
IMPLICIT NONE se place avant les dclarations des e variables, Linstruction ne sapplique qu` lunit de programme a e qui la contient.

Constantes littrales e
40
3.5
Constantes littrales e Constantes enti`res e
3.5.1
une suite de chires en base 10, une suite de chires en base 2 encadre par des quotes, e le tout prcd du caract`re B, e e e e une suite de chires en base 8 encadre par des quotes, e le tout prcd du caract`re O, e e e e une suite de chires en base 16 encadre par des quotes, e le tout prcd du caract`re Z. e e e e Une valeur ngative sera prcde du signe -. e e e e Exemple
1 123 -28 B11011011100 O3334 Z6DC
Remarque : les constantes crites en base 2, 8 ou 16 e sappellent des constantes BOZ. Elles ne peuvent gurer que dans les intructions dinitialisation de type DATA.

41
3.5.2
Constantes relles simple prcision e e
Une constante de type REAL doit obligatoirement comporter : soit le point dcimal, mme sil ny a pas de chires e e apr`s la virgule, e soit le caract`re E pour la notation en virgule ottante. e Pour les nombres crits 0.xxxxx, on peut omettre le 0 e avant le point dcimal. e Exemple
0. 1.0 1. 3.1415 31415E-4 1.6E-19 1E12 .001 -36.

42
3.5.3
Constantes relles double prcision e e
Une constante double precision doit obligatoirement tre crite en virgule ottante, le E tant remplac par un e e e e D. Exemple
0D0 0.D0 1.D0 1d0 3.1415d0 31415d-4 1.6D-19 1d12 -36.d0

43
3.5.4
Constantes complexes
Une constante de type COMPLEX est obtenue en combinant deux constantes relles entre parenth`ses spares par e e e e une virgule. 2.5+i scrira (2.5,1.) e Exemple
(0.,0.) (1.,-1.) (1.34e-7, 4.89e-8)

44
3.5.5
Constantes cha nes de caract`res e
Une constante cha nes de caract`res est une suite de e caract`res encadre par le dlimiteur ou bien ". e e e Si parmi la suite des caract`res gure le caract`re e e dlimiteur, il devra tre doubl. e e e Exemple
La somme des n premiers entiers est : ltendue dsire est : e e e "ltendue dsire est : " e e e
` A partir dune variable cha de caract`res on peut ne e extraire une suite de caract`res contigus. Pour cela on e spcie le nom de la variable suivi entre parenth`ses dun e e couple dentiers n:m indiquant les rangs de dbut et de n e dextraction. Exemple
CHARACTER(LEN=10) :: ch ch = "Bonjour" ch(4:7) = "soir"

Initialisation
45
3.6 3.6.1
Initialisation
Linstruction DATA
DATA liste1 /init1 /[, ..., listei /initi /, ...] listei fait rfrence ` une liste de variables ` initialiser, ee a a initi indique les valeurs dinitialisation, le type des valeurs dinitialisation doit respecter les r`gles suivantes : e pour un objet de type caract`re ou logique, la e constante dinitialisation doit tre de mme type, e e pour un objet de type entier, rel ou complexe, la e constante dinitialisation peut tre de type entier, e rel ou complexe. e

Initialisation Exemple
REAL INTEGER LOGICAL DATA DATA DATA A, B, C N, M arret A, B, N/1.0, 2.0, 17/ C/2.6/, M/3/ arret/.FALSE./
46
Remarques : cette instruction peut appara tre apr`s des instruce tions excutables, mais la norme F95 a dclar cette e e e possibilit comme obsol`te, e e les variables initialises par ce moyen hritent de e e lattribut SAVE : elles sont alors permanentes (cf. chapitre Procdures, section Dure de vie des e e identificateurs), il nest pas rare de trouver ce type dinitialisation lors de la dclaration comme dans lexemple suivant : ce e nest pas conseill car cela ne fait pas partie de la e norme donc non portable :
REAL INTEGER LOGICAL A/3.14/, B/2.718/ N/1/, M/4/ arret/.false./

Initialisation
47
3.6.2
Le symbole =
Fortran permet dinitialiser une variable lors de sa dclaration ` laide du symbole =. Dans ce contexte, les e a caract`res :: sont obligatoires. e
TYPE[, attributs] :: v1 = c1 [, ..., vi = ci , ...]
o` vi est le nom de la variable ` initialiser et ci sa valeur. u a Exemple

PROGRAM initialisation INTEGER :: debut = 100 REAL :: valeur = 76.3 LOGICAL :: drapeau = .TRUE. ... END PROGRAM initialisation
Note : ces variables hritent alors de lattribut SAVE, ce e qui implique que leur emplacement mmoire est permanent. e Pour plus de dtails, se reporter page 178 du support. e

Constantes symboliques
48
3.7
Constantes symboliques
Lattribut PARAMETER permet de donner un nom symbolique ` une constante littrale : a e

TYPE, PARAMETER :: n1 = c1 [, ..., ni = ci , ...]
o` ni est le nom donn ` une constante et ci sa valeur. u ea La notation suivante est aussi utilisable :
PARAMETER ( n1 = c1 [, ..., ni = ci , ...] )
Exemple
PROGRAM constante LOGICAL, PARAMETER :: VRAI=.TRUE., FAUX=.FALSE. DOUBLE PRECISION :: PI, RTOD PARAMETER (PI=3.14159265d0, RTOD=180.d0/PI) ... END PROGRAM constante

Instruction EQUIVALENCE
49
3.8
a Linstruction EQUIVALENCE permet ` des variables de partager la mme zone mmoire au sein dune unit de e e e programme, il ny a pas de conversion de type, chaque variable garde les proprits de son type. e e le type CHARACTER ne peut pas tre associ ` dautres e ea types.
Syntaxe gnrale e e
EQUIVALENCE (v1 , v2 )[, ..., (vi1 , vi ), ...] o` les vi sont des scalaires (variables simples ou lments u ee de tableaux).

50
Exemple-1
PROGRAM correspondance COMPLEX cmplx(2) REAL temp(4) EQUIVALENCE (temp(1), cmplx(1)) ... END PROGRAM correspondance
On a alors en mmoire : e
|--------cmplx(1)-------|--------cmplx(2)-------| |-----------|-----------|-----------|-----------| |--temp(1)--|--temp(2)--|--temp(3)--|--temp(4)--|

51
Exemple-2
PROGRAM correspondance CHARACTER(LEN=4) :: A, B CHARACTER(LEN=3) :: C(2) CHARACTER(LEN=10) :: chaine CHARACTER(LEN=1), DIMENSION(10) :: tab_car EQUIVALENCE (A,C(1)),(B,C(2)) EQUIVALENCE (chaine,tab_car(1)) ... END PROGRAM correspondance
On a alors en mmoire : e
| 01 | 02 | 03 | 04 | 05 | 06 | 07 | |---------A---------| |-----C(1)-----|-----C(2)-----| |---------B---------| | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | |-------------------- chaine ---------------------| | | |--> tab_car(1) |--> tab_car(7)

Plan
52
4 Oprateurs et expressions e
4.1 Oprateurs arithmtiques e e 4.2 Oprateurs relationnels e 4.3 Oprateurs logiques e 4.4 Oprateur de concatnation e e 4.5 Oprateur daectation e 4.6 Priorit des oprateurs e e

Oprateurs arithmtiques e e
53
4.1
4.1.1
Oprateur e + + * / **
Les oprateurs e
Opration e addition (oprateur binaire) e identit (oprateur unaire) e e soustraction (oprateur binaire) e oppos (oprateur unaire) e e multiplication division puissance

54
4.1.2
R`gle dusage e o1 + o2 + o1 o1 - o2 - o1 o1 * o2 o1 / o2 o1 **o2
Les expressions
Interprtation e ajoute o2 ` o1 a gal ` o1 e a soustrait o2 ` o1 a inverse le signe de o1 multiplie o1 par o2 o1 divis par o2 e l`ve o1 ` la puissance o2 ee a
Les oprandes o1 et o2 peuvent tre : e e une constante numrique, e une variable numrique, prcde ou non dun oprateur e e e e e unaire (+ ou -), une expression arithmtique entre parenth`ses. e e

55
Exemples dexpressions
3.14159 K (A + B) * (C + D) -1.0 / X + Y / Z ** 2 -2.0 * 3.14159 * RADIUS

56
4.1.3
Conversion implicite
Le type dune expression arithmtique dpend des types e e de ses oprandes. e Dans le cas doprateurs binaires : e si les 2 oprandes sont du mme type alors lexpression e e arithmtique rsultante sera de ce type. e e si les deux oprandes ne sont pas du mme type alors e e lexpression arithmtique sera value dans le type le e e e plus fort relativement ` la hirarchie suivante : a e INTEGER < REAL < DOUBLE PRECISION < COMPLEX Exemples
Expression ---------99/100 7/3 (100*9)/5 (9/5)*100 99./100 99./100d0 (1.,2.)+1 Valeur -----0 2 180 100 0.99 0.99d0 (2.,2.) type du rsultat e ---------------INTEGER INTEGER INTEGER INTEGER REAL DOUBLE PRECISION COMPLEX

57
Attention Soit lexpression d = 1.d0 +5. **0.5 avec la variable d dclare en DOUBLE PRECISION. La sous-expression e e e e e 5. **0.5 est value dans le type REAL car les oprandes de loprateur ** le sont. Le reste de lvaluation seectuera e e ensuite dans le type DOUBLE PRECISION, le rsultat tant e e nalement stock dans la variable d. e Mais cette variable d bien que du type DOUBLE PRECISION hrite dun calcul qui a commenc dans le type REAL, do` e e u une perte de prcision. e Cela peut induire par la suite des comportements inattendus lors de lvaluation dexpressions dans lesquelles e gurent cette variable (probl`me de convergence dans des e processus itratifs comme dans lexercice 3). e En conclusion, lors de lcriture dexpressions avec e prsence de constantes relles que lon dsire valuer en e e e e DOUBLE PRECISION, il est impratif dcrire ces constantes e e dans ce type. Ce qui donne pour lexpression prcdente : e e d = 1.d0 +5.d0 **0.5d0

Oprateurs relationnels e
58
4.2
Oprateurs relationnels e
Oprateur e .LT. ou < .LE. ou <= .EQ. ou == .NE. ou /= .GT. ou > .GE. ou >=
Opration e strictement plus petit infrieur ou gal e e gal e non gal e strictement plus grand suprieur ou gal e e
Ces oprateurs admettent des oprandes de type e e INTEGER, REAL ou CHARACTER. Seuls les oprateurs ==, /= e peuvent sappliquer ` des expressions de type COMPLEX. a Exemples
N .GE. 0 X .LT. Y Z /= 3.7 (B**2 - 4*A*C) .GT. 0.

Oprateurs logiques e
59
4.3
Oprateur e .NOT. .AND. .OR. .EQV. .NEQV.
Opration e ngation logique e conjonction logique disjonction inclusive quivalence logique e non-quivalence logique e
Les oprandes doivent tre des expressions de type e e LOGICAL.

60
4.3.1
Les tables de vrit e e
Oprateur de ngation : e e l .true. .false. Autres oprateurs : e l1 .true. .true. .false. .false. l1 .true. .true. .false. .false. l2 .true. .false. .true. .false. l2 .true. .false. .true. .false. l1 .AND.l2 .true. .false. .false. .false. l1 .EQV.l2 .true. .false. .false. .true. l1 .OR.l2 .true. .true. .true. .false. l1 .NEQV.l2 .false. .true. .true. .false. .NOT.l .false. .true.

Oprateur de concatnation e e
61
4.4
Oprateur de concatnation e e
Loprateur de concatnation nadmet que des exprese e sions de type CHARACTER.
Expression c1 // c2
Interprtation e concat`ne c1 avec c2 e
Exemple
BON // JOUR --> BONJOUR
CHARACTER(LEN=10) :: ch = BON ch = ch // JOUR ! <-- Inoprant !!! e ch = TRIM(ch) // JOUR ! <-- OK

Oprateur daectation e
62
4.5
4.5.1
syntaxe gnrale e e
variable = expression o` expression est une expression arithmtique, logique u e ou relationnelle.
4.5.2
R`gles de typage e
une valeur de type CHARACTER ne peut pas tre aecte e e ` une variable numrique ou vice-versa, a e une valeur de type INTEGER peut tre aecte ` une e e a variable de type REAL, e e e une valeur de type REAL peut galement tre aecte ` une variable de type INTEGER. Mais dans ce cas, a la valeur est alors tronque en supprimant la partie e fractionnaire.

63
Exemples
REAL x INTEGER N, M Expression x = 5 N = 0.9999 M = -1.9999 Interprtation e x = 5.0 N = 0 M = -1

Priorit des Oprateurs e e
64
4.6
Dans le tableau suivant, les oprateurs sont donns par e e ordre de priorit dcroissante : e e Oprateur e ** * et / + et // <, <=, == /=, >, >= .NOT. .AND. .OR. .EQV. et .NEQV. GD GD GD GD Associativit e DG GD GD GD GD

65
Exemples
REAL a,b,c,d LOGICAL e, f, g Expression 2**3**2 5.+4.*9.**2 e.OR.f.AND.g a**b+c.GT.d.AND.e Interprtation e 2**(3**2) = 512 5.+(4.*(9.**2)) = 329 e.OR.(f.AND.g) (((a**b)+c).GT.d).AND.e

plan
66
5 Structures de contrle o
5.1 Les tests 5.1.1 Le bloc IF 5.1.2 Le bloc SELECT-CASE 5.2 Les itrations e 5.2.1 Linstruction GOTO 5.2.2 Les bloucles DO

Les tests
67
5.1 5.1.1
Les tests Le bloc IF
[nom_bloc: ] IF( exp1 ) THEN bloc1 [ ELSE IF( exp2 ) THEN [nom_bloc] bloc2 ... [ ELSE [nom_bloc] blocn ]] END IF [nom_bloc] nom bloc une tiquette, e expi une expression de type LOGICAL, bloci une suite dinstructions Fortran. En labsence de clause ELSE lorsque bloc1 est rduit ` e a une seule instruction, la structure IF se simplie en : IF (exp) instruction

Les tests
68
Exemples
PROGRAM structure_if REAL A,B,SUM ... IF (A.LT.B) THEN SUM = SUM + A IF (SUM > 0.) PRINT *, SUM END IF ... END PROGRAM structure_if
PROGRAM structure_if REAL A,HRS ... IF (HRS.LE.40.0) THEN A = HRS*150.0 ELSE IF (HRS.LE.50.) THEN A = (HRS-40.0)*150.0*1.5 ELSE A = (HRS-50.0)*150.0*2.0 END IF ... END PROGRAM structure_if

Les tests
69
5.1.2
Le bloc SELECT-CASE
Linstruction SELECT CASE permet des branchements multiples qui dpendent de la valeur dune expression e scalaire de type entier, logique ou cha de caract`res. ne e [ nom_bloc: ] SELECT CASE(expression) [ CASE(liste) [ nom_bloc ] bloc1 ] ... [ CASE DEFAULT[ nom_bloc ] blocn ] END SELECT[ nom_bloc ] nom bloc est une tiquette, e expression est une expression de type INTEGER, LOGICAL ou CHARACTER, liste est une liste de constantes du mme type que e expression, bloci est une suite dinstructions Fortran.

Les tests
70
Exemples
PROGRAM structure_case integer :: mois, nb_jours logical :: annee_bissext ... SELECT CASE (mois) CASE (4, 6, 9, 11) nb_jours = 30 CASE (1, 3, 5, 7:8, 10, 12) nb_jours = 31 CASE (2) !---------------------------------fevrier: select case (annee_bissext) case (.true.) nb_jours = 29 case (.false.) nb_jours = 28 end select fevrier !---------------------------------CASE DEFAULT print *, Numro de mois invalide e END SELECT END PROGRAM structure_case

Les itrations e
71
5.2 5.2.1
Les itrations e
Linstruction GOTO
Linstruction GOTO permet deectuer un branchement ` un endroit particulier du code : a GOTO tiquette e Cette instruction est ` viter car elle peut gnrer des ae e e programmes illisibles et diciles ` corriger. a Exemple
PROGRAM iteration_goto REAL diviseur, valeur, facteur ... valeur = 0. ; diviseur = 360. 69 IF (diviseur .NE. 0.) THEN valeur = valeur + facteur / diviseur diviseur = diviseur - 10. GOTO 69 END IF ... END PROGRAM iteration_goto
Cet exemple peut tre remplac par une boucle itrative e e e de type DO WHILE.

Les itrations e
72
5.2.2
Les bloucles DO
Il existe plusieurs types de boucles itratives qui sont e toutes de la forme :

[ nom_bloc: ] DO [contr^le_de_boucle] o bloc END DO [ nom_bloc ]
nom bloc est une tiquette, e contr^le de boucle dnit les conditions dexcution o e e et darrt de la boucle, e bloc est une suite dinstructions Fortran.

Les itrations e 1re forme : DO indx e e contr^le de boucle est de la forme : o variable = expr1 , expr2 [,expr3 ] avec : variable est une variable de type INTEGER,
73
expr1 , expr2 et expr3 sont des expressions arithmtiques e de type INTEGER. Le nombre ditrations est valu avant le dmarrage de e e e e la boucle. Exemple
PROGRAM iteration_do INTEGER i, somme, n ... ! affectation de n somme=0 DO i=1,n,2 somme=somme+i END DO ... END PROGRAM iteration_do

Les itrations e
74
2e forme : DO WHILE contr^le de boucle est de la forme : o WHILE (expression) avec expression de type scalaire logique. Le corps de la boucle est excut tant que lexpression e e est vraie. Remarque : pour pouvoir sortir de la boucle, il faut que expression puisse prendre la valeur .FALSE. dans le bloc.

Les itrations e
75
Exemple
2 Sommation de la srie e a n1 1/n jusqu` ce que le terme gnral soit infrieur ` fois la somme partielle e e e a courante :
PROGRAM iteration_while INTEGER DOUBLE PRECISION DOUBLE PRECISION, PARAMETER LOGICAL
:: :: :: ::
n terme, somme epsilon = 1.d-3 fini
! Initialisation n=0 somme=0.d0 fini=.FALSE. DO WHILE (.not. fini) n=n+1 terme = 1d0/n**2 somme=somme + terme fini=(terme .LT. epsilon*somme) END DO print *,"Nombre ditrations : ", n e print *,"Somme = ", somme END PROGRAM iteration_while

Les itrations e
76
3e forme : DO Ce sont des boucles DO sans contr^le de boucle. Pour o en sortir, on utilise une instruction conditionnelle avec une instruction EXIT. bloc est de la forme : bloc1 IF (expression) EXIT bloc2 avec : expression une expression de type LOGICAL, bloci des squences de code Fortran. e Notons que la condition IF peut tre remplace par une e e instruction de type SELECT CASE.

Les itrations e
77
Exemple
PROGRAM iteration_exit REAL :: valeur REAL :: x, xlast REAL, PARAMETER :: tolerance = 1.0e-6 valeur = 50. x = 1.0 ! valeur initiale (diff. 0)
DO xlast = x x = 0.5 * (xlast + valeur/xlast) IF (ABS(x-xlast)/x < tolerance) EXIT END DO END PROGRAM iteration_exit

Les itrations e
78
Instruction CYCLE bloci peut aussi contenir une instruction CYCLE : IF (expression) CYCLE CYCLE permet dabandonner le traitement de litration e courante et de passer ` la suivante. a L` aussi, linstruction IF peut tre remplace par une a e e instruction de type SELECT CASE. Exemple
PROGRAM iteration_cycle INTEGER :: annee DO READ(*,*) annee IF (annee .LE. 0) EXIT ! On elimine les annes bissextiles. e IF ( ((annee/4*4 .EQ. annee) .AND. & (annee/100*100 .NE. annee)) .OR. & (annee/400*400 .EQ. annee) ) CYCLE PRINT*,Traitement des annes non-bissextiles e ... END DO END PROGRAM iteration_cycle

Plan
79
6 Tableaux
6.1 Dclaration e 6.2 Dnitions (rang, prol, tendue) e e 6.3 Initialisation 6.3.1 Le symbole = 6.3.2 Le constructeur de vecteurs 6.3.3 Linstruction DATA 6.4 Manipulation de tableaux

Dclaration e
80
6.1
Dclaration e
Un tableau est un ensemble dlments de mme type ee e contigus en mmoire. e Pour dclarer un tableau, il est recommand dutiliser e e lattribut DIMENSION : TYPE, DIMENSION(expr1 ,...,exprn ) :: liste tab avec : n 7 i.e un tableau peut avoir jusqu` 7 dimensions a expri sert ` indiquer ltendue dans la dimension a e correspondante. Cest une expression qui peut tre e spcie ` laide : e e a dune constante enti`re (littrale ou symbolique) ; e e dans ce cas, la borne infrieure du tableau est 1, e dune expression de la forme cste1 : cste2 avec cste1 , cste2 des constantes enti`res telles que e cste1 <= cste2 , liste tab est une liste de tableaux.

Dclaration e
81
Exemples
INTEGER, PARAMETER REAL, DIMENSION (0:lda-1) REAL, DIMENSION (1+lda*lda,10) REAL, DIMENSION (100) REAL, DIMENSION (1:5,1:5, 1:5) REAL, DIMENSION (-10:-1) :: lda = 6 :: Y :: Z :: R :: S :: X
Exemple Remarque : les dimensions dun tableau peuvent aussi tre spcies sans lattribut DIMENSION : e e e
REAL :: T(10,10), U(4,2), G(-1:10,4:9,1:3)
Attention, cette notation nest pas recommande ! e

Dnitions (rang, prol, tendue) e e
82
6.2
Le rang (rank ) dun tableau est son nombre de dimensions. Le nombre dlments dans une dimension sappelle ee ltendue (extent) du tableau dans cette dimension. e Le prol (shape) dun tableau est un vecteur dont chaque lment est ltendue du tableau dans la ee e dimension correspondante. La taille (size) dun tableau est le produit des lments ee du vecteur correspondant ` son prol. a Deux tableaux sont dits conformants sils ont le mme e prol.

83
Exemples
REAL, DIMENSION (15) :: X REAL, DIMENSION (1:5,1:3) :: Y REAL, DIMENSION (-1:3,0:2) :: Z
Le tableau X est de rang 1, Y et Z sont de rang 2. Ltendue de X est 15, Y et Z ont une tendue de 5 et 3. e e Le prol de X est le vecteur (/ 15 /), celui de Y et Z est le vecteur (/ 5,3 /) La taille des tableaux X, Y et Z est 15. Les tableaux Y et Z sont conformants.

Dnitions (rang, prol, tendue) e e Ordre des lments ee En mmoire la notion de tableau nexiste pas : les e lments sont rangs les uns ` la suite des autres. ee e a Pour accder ` ces lments, dans lordre mmoire, e a ee e Fortran fait dabord varier le premier indice, puis le second et ainsi de suite. Par exemple, les lments dun tableau ` deux dimenee a sions sont ordonns comme suit : e REAL, DIMENSION(5,3) :: C C(1,1),C(2,1),..,C(5,1),C(1,2),C(2,2),..,C(5,3)
84
C(1,1)
C(1,3)
C(5,1)
C(5,3)

Initialisation
85
6.3 6.3.1
Initialisation Le symbole =
Fortran permet de manipuler globalement lensemble des lments dun tableau. ee On pourra alors utiliser le symbole = comme pour linitialisation dune variable scalaire. Exemple Pour initialiser ` 3 lensemble dun vecteur : a
REAL, DIMENSION(100) :: X = 3.

Initialisation
86
6.3.2
Le constructeur de vecteurs
Un constructeur de vecteur est un vecteur de scalaires dont les valeurs sont encadres par les caract`res (/ et /) : e e tableau = (/ expr1 , expr2 , ..., exprn /) tableau est un tableau de rang 1, expri est : un scalaire, une boucle DO implicite de la forme (expr scalaire, variable = m1 ,m2 [,m3 ]) avec variable une variable INTEGER correspondant ` a lindice de cette boucle et m1 , m2 , m3 des constantes enti`res dlimitant la boucle (voir boucle DO). e e Le constructeur et le tableau tableau doivent tre e conformants.

Initialisation
87
Exemple
IMPLICIT NONE REAL, DIMENSION(4) :: heights = (/ 5.10, 5.6, 4.0, 3.6 /) &
CHARACTER(len=5), DIMENSION(3) :: colours = & (/ RED , GREEN, BLUE /) INTEGER :: i INTEGER, DIMENSION(10) :: ints = (/ 100, (i, i=1,8), 100 /)
&

Initialisation
88
6.3.3
Linstruction DATA
Comme pour les variables simples, on peut utiliser linstruction DATA pour initialiser les tableaux lors de leur dclaration. Elle permet dinitialiser tout ou partie de e tableaux ` laide dune liste de constantes encadre par le a e caract`re / (la notation n*valeur peut tre employe pour e e e rpter une mme valeur). e e e Les lments ` initialiser peuvent tre spcis au moyen ee a e e e dune boucle DO implicite : (tab(i), i = m1 ,m2 [,m3 ]). Exemple
IMPLICIT NONE INTEGER REAL, DIMENSION(20) INTEGER, DIMENSION(10) REAL, DIMENSION(2,3) DATA DATA DATA DATA
:: i, j :: A, B :: ints :: MAT
A/20*7.0/, B/10., 3.87, 10.5/ (ints(i),i=1,4)/4*6/, A(10)/-1.0/ MAT/1., 2., 3., 4., 5., 6./ ((MAT(i,j),j=1,3),i=1,2)/1., 2., 3., & 4., 5., 6./

Manipulation de tableaux
89
6.4 6.4.1
Manipulation de tableaux Expressions de type tableau
Les tableaux peuvent tre utiliss en tant quoprandes e e e dans une expression : les oprateurs intrins`ques sont applicables ` des e e a tableaux conformants, les fonctions lmentaires sappliquent ` lensemble du ee a tableau. Dans ces cas, les fonctions ou oprateurs sont appliqus e e ` chaque lment du tableau (log, sqrt, ...). a ee Exemple
REAL, DIMENSION(-4:0,0:2) :: B REAL, DIMENSION(5,3) :: C REAL, DIMENSION(0:4,0:2) :: D ... B = C * D - B**2 B = SIN(C)+COS(D)

90
6.4.2
Sections de tableaux
Les sections rguli`res de tableaux sont dcrites ` e e e a laide dun triplet : [limite1 ]:[limite2 ][:pas]
cette notation est quivalente ` une pseudo-boucle, e a une section de tableau est aussi un tableau, le rang dune section de tableau est infrieur ou gal ` e e a celui du tableau global, la section dmarre ` limite1 et se termine ` ou avant e a a limite2 , pas est lincrment des indices. e

91
Exemples
A( : ) A( 3:9 ) A( 3:9:1 ) A( m:n ) A( m:n:k ) A( 8:3:-1 ) A( 8:3 ) A( m: ) A( :n ) A( ::2 ) A( m:m ) A( m ) ! ! ! ! ! ! ! ! ! ! ! ! ! Le tableau global A(3) a A(9) par pas de 1 ` Idem A(m) a A(n) ` A(m) a A(n) par pas de k ` A(8) a A(3) par pas de -1 ` A(8) a A(3), pas de 1 => taille nulle ` de A(m) a la borne suprieure de A ` e de la borne infrieure de A a A(n) e ` borne inf. de A a borne sup., pas de 2 ` section constitue de 1 elment e e (ce nest pas un scalaire !) section equivalente a un scalaire `
Seules les oprations sur des sections conformantes sont e valides :

REAL, DIMENSION(1:6,1:8) :: P P( 1:3 , 1:4 ) = P( 1:6:2 , 1:8:2 ) ! VALIDE P( 2:8:2 , 1:7:3 ) = P( 1:3 , 1:4 ) ! INVALIDE P( 2:6:2 , 1:7:3 ) = P( 2:5 , 7 ) ! INVALIDE

92
Exemples
REAL, DIMENSION(1:6,1:8) :: P
P(1:3,1:4)
P(2:6:2,1:7:3)
P(2:5,7), P(2:5,7:7)
P(1:6:2,1:8:2)
Attention, P(2:5,7) est une section 1D tandis que P(2:5,7:7) est une section 2D : ces 2 tableaux ne sont donc pas conformants.

Plan
93
7 Entres-Sorties e
7.1 - Introduction 7.2 - Acc`s squentiel e e 7.2.1 - Fichier binaire squentiel e 7.2.2 - Fichier texte squentiel e 7.2.2.1 - Format ddition e 7.2.2.2 - namelist 7.3 - Acc`s direct e 7.3.1 - Fichier binaire ` acc`s direct a e 7.3.2 - Fichier texte ` acc`s direct a e 7.4 - Fichier temporaire 7.5 - Destruction dun chier 7.6 - Fichier interne 7.7 - Instructions de positionnement 7.8 - Linstruction INQUIRE 7.9 - Remarques 7.10 - Syntaxes

Introduction
94
7.1
Introduction
On appelle entre-sortie, un transfert dinformae tions entre la mmoire de lordinateur et lun de ses e priphriques (un disque le plus souvent). e e Une entre se traduit par une lecture dinformae tions du priphrique vers la mmoire, tandis quune e e e sortie implique une criture de la mmoire vers le e e priphrique. e e Ces informations sont stockes dans un chier qui e poss`de un nom. e Lunit de transmission entre la mmoire et le e e priphrique sappelle le bloc. Il permet deectuer e e le traitement en passant par une zone intermdiaire e dite zone tampon (buer ) permettant ainsi de limiter le nombre de transferts entre la mmoire et le e priphrique : opration coteuse. e e e u Lunit de traitement est lenregistrement logique : e il correspond ` la longueur des donnes traites lors a e e dune opration de lecture-criture. e e

Introduction
95
Lexploitation dun chier au sein dun programme ncessite au pralable son ouverture qui, en Fortran, e e est faite au moyen de linstruction OPEN. Cette instruction permet notamment : de connecter le chier ` un numro dunit logique : a e e cest celui-ci que lon indiquera par la suite pour toute opration de lecture-criture, e e de spcier le mode dsir : lecture, criture ou e e e e lecture-criture, e dindiquer le mode de transfert : avec ou sans conversion en caract`res, e dindiquer le mode dacc`s au chier : squentiel e e ou direct. Si louverture du chier est fructueuse, des lecturescritures pourront tre lances ` laide des instructions e e e a READ/WRITE par lintermdiaire du numro dunit e e e logique. Une fois le traitement du chier termin, on le e fermera au moyen de linstruction CLOSE.

Acc`s squentiel e e
96
7.2
Acc`s squentiel e e
On dit quun chier est squentiel lorsquil est e ncessaire davoir trait les enregistrements prcdant e e e e celui auquel on dsire accder. e e Pour un chier en lecture le param`tre IOSTAT de e linstruction READ permet notamment de grer la n de e chier ; celui-ci fait rfrence ` une variable enti`re qui ee a e est valorise ` lissue de la lecture comme suit : e a ` 0 si la lecture sest bien droule, a e e ` une valeur positive si une erreur sest produite, a ` une valeur ngative si la n de chier ou une n a e denregistrement a t rencontre. ee e On prendra soin de tester la valeur de cette variable immdiatement apr`s chaque lecture. e e Pour une analyse plus ne des erreurs de lecture se reporter ` la page 159. a

Fichier binaire squentiel e
97
7.2.1
Fichier binaire squentiel e
On appelle chier binaire un chier dans lequel on stocke les informations telles quelles sont reprsentes e e en mmoire. e Cest au moment de louverture du chier que lon indique le type de chier ` tra a ter.
real, dimension(100) integer real integer :: :: :: :: tab i r ios
OPEN ( UNIT =1, & FILE ="data_bin_seq", & FORM ="unformatted", & ACCESS ="sequential", & ACTION ="read", & POSITION ="rewind", & IOSTAT =ios ) if ( ios /= 0 ) stop "Probl`me a louverture" e ` READ ( UNIT =1, IOSTAT =ios ) tab, i, r do while ( ios == 0 ) ... READ ( UNIT =1, IOSTAT =ios ) tab, i, r end do CLOSE ( UNIT =1 )

Fichier binaire squentiel e On demande louverture du chier dont le nom est data bin seq. Cest un chier binaire squentiel e (unformatted, sequential) que lon dsire lire depuis e le dbut (rewind). e Ce chier est connect ` lunit logique dont le numro ea e e est 1. Cest ce numro que lon indique au moment de la e lecture des variables tab, i, r, ainsi qu` la fermeture du a chier. En cas derreur lors de louverture dun chier, en labsence du mot-cl IOSTAT le programme sinterrompt e avec dition dun message rsumant lerreur. Ici ce mot-cl e e e est prcis. Il permet de personnaliser le traitement en e e cas derreur. Il fait rfrence ` une variable enti`re (ici la ee a e variable ios) laquelle, ` lissue de lOPEN, est valorise de la a e faon suivante : c ` zro si tout sest bien pass, a e e ` une valeur non nulle si une erreur sest produite. a Il faudra videmment la tester avant dentreprendre e toute opration dentre-sortie sur le chier. e e Ce mme mot-cl est prcis au sein de linstruction e e e e READ. Il rfrence la mme variable ios qui re`tera ltat ee e e e de la lecture une fois celle-ci eectue. Elle est utilise pour e e notamment grer la n de chier. e
98

Fichier texte squentiel e
99
7.2.2
Dans un chier texte les donnes sont stockes sous e e forme de caract`res. De ce fait : e lors dune lecture, elles sont converties en binaire avant dtre ranges en mmoire, e e e lors dune criture, elles sont converties en cae ract`res avant dtre crites dans le chier. e e e Cette opration de conversion est signale au sein e e des instructions READ/WRITE : ` laide dune cha de caract`res appele format a ne e e ddition (param`tre FMT=), e e ou bien en utilisant un nom de liste (NAMELIST) regroupant les variables que lon dsire exploiter e (param`tre NML=). e

100
Formats ddition e
Pour que la conversion puisse tre faite, il est e ncessaire de conna le type de la donne ` convertir. e tre e a Pour cela le format ddition contient des dese cripteurs : descripteur I pour le type INTEGER, descripteurs F, E pour le type REAL, descripteur L pour le type LOGICAL, descripteur A pour le type CHARACTER.

101
Exemple
PROGRAM texte_sequentiel real, dimension(10) :: integer :: real :: integer ::
tab i r ios
OPEN ( UNIT =1, & FILE ="data_txt_seq", & FORM ="formatted", & ACCESS ="sequential", & STATUS ="old", & ACTION ="write", & POSITION ="rewind", & IOSTAT =ios ) if ( ios /= 0 ) then ! Probl`me a louverture e ` ... else WRITE ( UNIT =1, & FMT =(10F8.4,I3,F6.3)) tab, i, r ... endif ... CLOSE ( UNIT =1 ) END PROGRAM texte_sequentiel

102
Dans cet exemple, on demande louverture du chier dont le nom est data txt seq. Cest un chier texte squentiel (formatted, sequential) existant (old) e que lon dsire craser (rewind). e e Comme prcdemment, ` lissue de lOPEN on teste e e a la valeur de retour contenue dans lentier ios. Si louverture sest bien passe on lance, ` laide e a de linstruction WRITE, lcriture en caract`res dun e e enregistrement comportant un tableau de rels (tab) e suivi dun entier puis dun rel (i, r). e Le format ddition spci sous la forme dune e e e constante cha de caract`res ((10F8.4,I3,F6.3)) ne e permet de convertir en caract`res les variables cie dessus : 10F8.4 : criture des 10 lments du tableau tab. e ee Chacun a un gabarit de 8 caract`res avec 4 chires e en partie dcimale, e I3 : criture de lentier i sur 3 caract`res, e e F6.3 : criture du rel r sur 6 caract`res avec 3 e e e chires en partie dcimale. e

103
Formats ddition en lecture e
Iw permet la conversion des w caract`res suivants e dans le type INTEGER, Fw.d : permet la conversion des w caract`res e suivants dans le type REAL. Si le point dcimal e nest pas prsent alors les d derniers caract`res e e dsignent la partie fractionnaire, e Ew.d : permet la conversion des w caract`res e suivants (interprts comme un nombre rel en ee e notation exponentielle) dans le type REAL, Lw : permet la conversion des w caract`res suivants e dans le type LOGICAL, A[w ] : permet de lire des caract`res. e

104
Exemples
Dans ce qui suit le caract`re ^ reprsente lespace. e e Les direntes entres prsentes sont supposes gurer e e e e e dans un chier texte squentiel connect ` lunit 1 e e a e apr`s un OPEN. e
Format ddition I en lecture e
INTEGER i, j ... READ( UNIT=1, FMT=( I5 , I4 ) ) i, j ...
Entres e ^^45^^^9^ ^-24^10^^
Affectations i=45, j=9 i=-24, j=10
` A noter : dans un champ en entre, lespace est e ignor. e

Fichier texte squentiel e Formats ddition F, E et D en lecture e
105
Ce format ` la forme gnrale : Fw.d , Ew.d ou bien a e e Dw.d . Le nombre rel ` lire peut tre soit en notation e a e virgule xe, soit exponentielle avec, dans ce dernier cas, lexposant prx de la lettre E ou D. e e Le point dcimal peut ne pas gurer : e sil est spci alors le nombre indiqu par d est e e e ignor, cest le nombre de dcimales gurant en e e entre qui est pris en compte, e sil est omis cest le nombre indiqu par d qui est e considr. ee
REAL x, y ... READ( UNIT=1, FMT=( F4.1 , F6.2 ) ) x, y ...
Entres e ^3.1-3.141 ^123^^5678
Affectations x=3.1, y=-3.141 x=12.3, y=56.78

106
REAL x ... READ( UNIT=1, FMT=( E12.6 ) ) x ! ou bien READ( UNIT=1, FMT=( F12.6 ) ) x ...
Entres e 2.718281^^^^ 2718281^^^^^ 27.18281d-1^ .2718281e+1^ .2718281^e^1 ^^^^^2718281 ^^^^^^^^^271
Affectations x=2.718281 x=2.718281 x=2.718281 x=2.718281 x=2.718281 x=2.718281 x=0.000271

107
Format ddition L en lecture e
Ce format ` la forme gnrale : Lw a e e Ce type de format permet la lecture de valeurs logiques. Le caract`re w indique comme prcdemment la e e e largeur du champ en entre. Celui-ci doit comporter e comme premier caract`re non blanc lune des lettres e F, f, T ou t ventuellement prcde du caract`re e e e e e .. Nimporte quels caract`res peuvent complter le e e champ.
LOGICAL l1, l2 ... READ( UNIT=1, FMT=( L6 , L7 ) ) l1, l2 ...
Entres e .true..false. ^^^^t..FACILE t^^^^^F^^^^^^
Affectations l1=.TRUE., l2=.FALSE. l1=.TRUE., l2=.FALSE. l1=.TRUE., l2=.FALSE.

108
Format ddition A en lecture e
Ce format ` la forme gnrale : A[w ] a e e Ce type de format permet la lecture de caract`res. e La valeur w indique le nombre de caract`res que lon e dsire traiter en entre. e e si la valeur de w est plus grande que la longueur l de la cha rceptrice, ce sont les l caract`res les ne e e plus ` droite qui seront lus, a si elle est plus petite, w caract`res seront lus e et stockes dans la cha rceptrice qui sera e ne e complte ` droite par des blancs, ee a si elle nest pas prcise, cest la longueur spcie e e e e lors de la dclaration de la cha de caract`res qui e ne e indiquera le nombre de caract`res ` lire. Si la n e a de lenregistrement est atteinte avant la n de la lecture, la cha est complte par des blancs. ne ee

109
Exemples
CHARACTER(len=7) :: ch1, ch2 ... READ( UNIT=1, FMT=( A6 , A8 ) ) ch1, ch2 READ( UNIT=1, FMT=( A6 , A8 ) ) ch1, ch2 READ( UNIT=1, FMT=( A , A ) ) ch1, ch2 ...
Entres e
BACH^^^^BACH^^ MOZARTHAENDEL^ MOZARTHAENDEL^
Affectations
ch1="BACH^^^",ch2="^BACH^^" ch1="MOZART^",ch2="AENDEL^" ch1="MOZARTH",ch2="AENDEL^"

110
Formats ddition en criture e e
Iw [.d ] permet ldition dune variable de type e INTEGER sur w caract`res. Sil est prsent d indique e e le nombre minimum de chires dits : si ncessaire e e e des 0 appara tront en tte du nombre, e Fw.d : permet ldition dune variable de type REAL e sur w caract`res comprenant le point dcimal suivi e e de d chires pour la partie fractionnaire, Ew.d : idem format F mais la sortie est faite en notation exponentielle, Lw : permet ldition dune variable de type e LOGICAL sur w caract`res, e A[w ] : permet ldition dune variable de type e CHARACTER.

111
Format ddition I en criture e e

INTEGER i, j, k i = -125 j = 1756 k = 1791 WRITE( UNIT=1, FMT=( I4 , I4 , I4 ) ) i, j, k WRITE( UNIT=1, FMT=( I5 , I6 , I6 ) ) i, j, k WRITE( UNIT=1, FMT=( I6.5 , I6.6 , I6.6 ) ) i, j, k
Sorties -12517561791 ^-125^^1756^^1791 -00125001756001791

112
Format ddition F en criture e e

REAL x, y, z x = 3.14159 y = -15.137 z = 799.7432 WRITE( UNIT=1, & FMT=( F7.5 , F8.3 , F9.4 ) ) x, y, z WRITE( UNIT=1, & FMT=( F6.2 , F9.4 , F10.5 ) ) x, y, z
Sorties 3.14159^-15.137^799.7432 ^^3.14^-15.1370^799.74323

113
Remarque
En ce qui concerne les formatsa dcriture I, B, e O, Z et F, lorsque le gabarit de la zone rceptrice est e insusant celle-ci est remplie par le caract`re *. Depuis e la norme Fortran 95 il est possible dviter cela en e indiquant 0 comme largeur de zone.
Exemples
PROGRAM gabarit INTEGER I REAL R I = 129876 R = -2345.78 WRITE( UNIT=1, FMT=(I4, F6.3) ) I, R WRITE( UNIT=1, FMT=( I0 , F0 .3) ) I, R END PROGRAM gabarit Sorties ********** 129876-2345.780
a formats
B, O, Z : c.f. Remarques en n de chapitre.

114
Format ddition E et D en criture e e
Avec les format Ew.d , Dw.d on obtiendra en sortie le motif :

S0.XXXXXXXESXX, S0.XXXXXXXDSXX <--d--> <--d--> <-----w------> <-----w------>
Le caract`re S indique une position pour le signe. e Un facteur dchelle peut prcder ce type de e e e format. Il scrit sous la forme kP et permet dditer le e e nombre avec k chires avant le point dcimal (modie e en consquence la valeur de lexposant). e Si d < k 0, la partie dcimale sera constitue de e e |k| zros suivis de d |k| chires signicatifs. e Si 0 < k < d + 2, le nombre en sortie sera constitu e de k chires signicatifs avant le point dcimal et de e d k + 1 chires signicatifs en partie dcimale. e Toute autre valeur de k est invalide : dans ce cas, la zone en sortie sera remplie par le caract`re . e Celui-ci sapplique ` tous les formats E qui suivent. a Pour retrouver le comportement par dfaut il sut de e prciser le facteur 0P. e

115
Exemples
REAL x, y, z DOUBLE PRECISION xd, yd, zd x = 3.14159; xd = 3.14159d0 y = -15.137; yd = -15.137d0 z = 799.74328; zd = 799.74328d0 WRITE( UNIT=1, & FMT=( D12.6 , E13.5 , E15.8 ) ) x, y, z WRITE( UNIT=1, & FMT=( 4P , D12.6 , E13.5 , 0P , E10.3 ) ) x, y, z WRITE( UNIT=1, & FMT=( D12.6 , E13.5 , E15.8 ) ) xd, yd, zd WRITE( UNIT=1, & FMT=( 4P , D12.6 , E13.5 , 0P , E15.8 ) ) xd, yd, zd
Sorties 0.314159D+01^-0.15137E+02^0.79974329E+03 3141.590D-03^-1513.70E-02^0.800E+03 0.314159D+01^-0.15137E+02^0.79974328E+03 3141.590D-03^-1513.70E-02^0.79974328E+03

116
Il existe deux variantes du format E qui correspondent aux descripteurs EN et ES. Le facteur dchelle e kP ne peut tre appliqu dans ce contexte. e e Le descripteur EN permet la sortie dun rel en noe tation dite ingnieure. Dans ce type de reprsentation, e e la valeur absolue de la partie enti`re est suprieure ou e e gale ` 1 et infrieure ` 1000 et lexposant est divisible e a e a par 3.
REAL x, y, z, t x = 6.421 y = -.5 z = .00217 t = 4721.3 WRITE( UNIT=1, & FMT=( EN12.3 , EN12.3 , EN12.3 , EN12.3 ) ) & x, y, z, t
Sorties
^^^6.421E+00-500.000E-03^^^2.170E-03^^^4.721E+03

117
Le descripteur ES permet la sortie dun rel en noe tation dite scientique. Dans ce type de reprsentation, e la valeur absolue de la partie enti`re est suprieure ou e e gale ` 1 et infrieure ` 10. e a e a
REAL x, y, z, t x = 6.421 y = -.5 z = .00217 t = 4721.3 WRITE( UNIT=1, & FMT=( ES12.3 , ES12.3 , ES12.3 , ES12.3 ) ) & x, y, z, t
Sorties
^^^6.421E+00^^-5.000E-01^^^2.170E-03^^^4.721E+03

118
Par dfaut, la prsence du signe + pour les donnes e e e numriques positives dpend du compilateur. Il existe e e des descripteurs permettant de forcer sa prsence ou e bien de le supprimer : SS (sign suppress) : le signe + nappara pas, t SP (sign print) : le signe + prc`de la donne, e e e S : restauration du mode par dfaut. e
INTEGER i, j REAL x, y i = 1756 j = -69 x = 6.421 y = .00217 WRITE( UNIT=1, & FMT=( SP ,F7.3, SS , ES12.3 ,I4, SP ,I6) ) x, y, j, i
Sorties
^+6.421^^^2.170E-03^-69^+1756

119
Format ddition L en criture e e
Ce format ` la forme gnrale : Lw a e e Ce type de format permet lcriture de valeurs e logiques. En sortie on obtiendra w-1 blancs suivis de la lettre T pour une valeur .true. et F pour une valeur .false..
LOGICAL l1/.true./, l2/.false./ ... WRITE( UNIT=1, FMT=( L6 , L7 ) ) l1, l2 ...
Sorties ^^^^^T^^^^^^F

120
Format ddition A en criture e e
Le format A[w ] permet la sortie de cha nes de caract`res. La valeur w est facultative. Si elle est e prcise, elle indique la largeur de la zone rceptrice. e e e si la valeur de w est plus grande que la longueur l de la cha ne, en sortie celle-ci appara tra prcde e e e de w -l blancs, si elle est plus petite, seuls les w caract`res les plus e a ` gauche de la cha seront crits, ne e si la valeur w est absente, cest la longueur de la cha spcie ` la dclaration qui indique la ne e e a e largeur du champ en sortie.

121
Exemples
CHARACTER(len=9) :: ch1, ch2, ch3 ... ch1 = "BEETHOVEN" ch2 = "PUCCINI" ch3 = "VERDI" WRITE( UNIT=1, FMT=( A9 , A8 , A6 , A ) ) ch1, & ch2, & ch3, & ch3 WRITE( UNIT=1, FMT=( A10 ) ) ch3 ch1 = "Ludwig" ch2 = " Van" ch3 = "BEETHOVEN" WRITE( UNIT=1, FMT=( A , A , A , A ) ) trim(ch1), & trim(ch2), & , & ch3 ...
Sorties
BEETHOVENPUCCINI^VERDI^VERDI^^^^ ^VERDI^^^^ Ludwig^Van^BEETHOVEN

122
Format ddition : Litteral string e
Si une constante littrale de type cha de cae ne ract`res est spcie dans un format, celle-ci est e e e reproduite telle quelle en sortie.
CHARACTER(len=9) :: ch1, ch2, ch3 ... ch1 = "Ludwig" ch2 = " Van" ch3 = "BEETHOVEN" WRITE( UNIT=1, & FMT=( "NOM : " ,A, ", PRNOM : " ,A,A) ) & E ch3, trim(ch1), trim(ch2) ...
Sortie
NOM^:^BEETHOVEN,^PRNOM^:^Ludwig^Van E

123
Descripteurs de contrle o
descripteurs de positionnement : n X : ignore (en entre), saute (en sortie) les n e caract`res suivants, e Tc : permet de se positionner au caract`re de e rang c, TLn : permet de se positionner au caract`re e situ n positions ` gauche par rapport ` la e a a position courante, TRn : permet de se positionner au caract`re e situ n positions ` droite par rapport ` la e a a position courante. descripteurs de gestion des blancs dans les champs numriques en entre : e e BN (Blank Null ) : ignore les blancs, BZ (Blank Zero) : interpr`te le caract`re blanc e e comme un 0.

124
INTEGER i, j, k, l ... READ( UNIT=1, & FMT=(I4, 3X ,I2, T12 ,I3, TL4 ,I1) ) i, j, k, l ...
Entres e 1901^1254^4361
Affectations i=1901,j=54,k=361,l=4
INTEGER i, j, k ... READ( UNIT=1, & FMT=(I3, BZ ,I2, BN ,I3) ) i, j, k ...
Entres e ^8^2^4^^
Affectations i=8,j=20,k=4

125
Un autre descripteur, /, provoque le passage a ` lenregistrement suivant : en entre : abandon de lenregistrement courant et e positionnement au dbut du suivant, e
INTEGER i, j READ( UNIT=1, FMT=(I4, / ,I4)) i, j
Entres e
1756^1254 1791
Affectations
i=1756,j=1791
en sortie : criture du caract`re newline . e e

CHARACTER(len=9) :: ch1, ch2, ch3 ch1 = "Ludwig" ch2 = " Van" ch3 = "BEETHOVEN" WRITE( UNIT=1, & FMT=("NOM : ",A, / ,"PRNOM : ",A,A) ) & E ch3, trim(ch1), trim(ch2)
Sortie
NOM^^^^:^BEETHOVEN PRNOM^:^Ludwig^Van E

126
Facteur de rptition e e
Lorsquune liste de descripteurs identiques gure dans un format il est possible de les regrouper au moyen dun facteur de rptition indiqu sous la forme dune e e e constante littrale enti`re. e e
INTEGER i, j, k INTEGER t(3) ... READ( UNIT=1, FMT=(I4,I4,I4) ) i, j, k READ( UNIT=1, FMT=( 3 I4) ) t ... WRITE(6, ( 3 (1X,I4))) t
Entres e ^^45^^^9^^10 ^-24^10^^^99
Affectations i=45, j=9, k=10 t(1)=-24, t(2)=10, t(3)=99 Sortie ^^-24^^^10^^^99

127
Rexploration dun format e
Lensemble des variables spcies dans une inse e truction READ/WRITE sappelle la liste dentre-sortie. e Chaque lment de cette liste est associ ` un descripee ea teur du format. si le nombre de descripteurs correspond au nombre de variables de la liste, ceux-ci sappliquent aux lments successifs de cette liste, ee sil est plus grand, les suivants sont ignors (le e format est abandonn), e sil est plus petit, le format est rexplor. Cette e e rexploration entra le passage ` lenregistrement e ne a suivant.
Conclusion : en Fortran la liste dentre-sortie e est toujours satisfaite .

128
La r`gle de rexploration est la suivante : e e si le format ne contient aucun groupe de descripteurs entre parenth`ses, alors il est rexplor depuis e e e son dbut, e sinon, la rexploration est faite ` partir du groupe e a de niveau 1 le plus ` droite. Sil est prcd dun a e e e facteur de rptition, il est pris en compte. e e
Exemples
Le caract`re | indique lendroit ` partir duquel la e a rexploration est eectue. e e

( I6, 10X,I5, 3F10.2 ) |------------------( I6, 10X,I5, (3F10.2) ) |-------( I6,(10X,I5), 3F10.2 ) |---------------( F6.2, (2F4.1,2X,I4, 4(I7,F7.2)) ) |-------------------------( F6.2, 2(2F4.1,2X,I4), 4(I7,F7.2) ) |---------( F6.2,(2(2F4.1,2X,I4), 4(I7,F7.2)) ) |-----------------------------

129
Exemples
INTEGER :: i=100, j=200 ! depuis Fortran 90. INTEGER :: k, l DATA k/300/, l/400/ ! ancienne forme ! dinitialisation. REAL t(3,4) DATA t/ 1., 4., 9., & 16., 25., 36., & 49., 64., 81., & 100., 121., 144. / WRITE(6, ( 4i5, ( t25,4f8.2) )) & i, j, k, l, & ((t(i,j),j=1,4),i=1,3)
Sorties
^^100^^200^^300^^400^^^^^^^^1.00^^^16.00^^^49.00^^100.00 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^4.00^^^25.00^^^64.00^^121.00 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^9.00^^^36.00^^^81.00^^144.00

Fichier texte squentiel e Format libre
130
En Fortran il existe un format implicite appel e format libre (list-directed formatting). Dans linstruction READ/WRITE, on spcie alors le e caract`re * ` la place du format. e a Dans ce contexte, les enregistrements sont interprts comme une suite de valeurs spares par ee e e des caract`res appels sparateurs. Cest le type des e e e variables auxquelles ces valeurs vont tre aectes qui e e dtermine la conversion ` eectuer. e a Les caract`res interprts comme des sparateurs e ee e sont : la virgule (,), le blanc (espace). Une cha de caract`res contenant un caract`re ne e e sparateur doit tre dlimite soit par des quotes () e e e e soit par des guillemets ("). En entre, plusieurs valeurs identiques peuvent tre e e regroupes ` laide dun facteur de rptition sous la e a e e forme n*valeur.

131
Une constante complexe est code comme 2 nombres e rels entre parenth`ses spars par une virgule. Les e e e e parenth`ses ainsi que la virgule peuvent tre suivies ou e e prcdes de blancs. e e e Une n denregistrement (newline) a le mme eet e quun blanc. Elle peut appara : tre au sein dune cha de caract`res (dlimite par ne e e e des quotes () ou par des guillemets (")), entre la partie relle et la virgule ou entre la virgule e et la partie imaginaire dune constante complexe. Si une cha de caract`res a t dclare avec une ne e ee e e longueur plus petite que celle de la valeur lue alors seuls les caract`res les plus ` gauche de la valeur seront e a stocks dans la cha Sinon, celle-ci est complte par e ne. ee des blancs. Si dans lenregistrement en entre apparaissent e deux virgules ` la suite (ventuellement avec des blancs a e entre) alors llment correspondant de la liste ne sera ee pas modi. e

132
Exemples
INTEGER i/100/, & j/200/, & k/300/ REAL t(3) COMPLEX c CHARACTER(len=8) ch ... READ ( UNIT=1, FMT=* ) i, j, k, t, c, ch WRITE( UNIT=2, FMT=* ) i, j, k, c, ch WRITE( UNIT=2, FMT=* ) t
Entres e
150 260,, 3*2.718 (^2. ,^3.^)^^^Wolfgang Amadeus Mozart
Affectations
i=150 j=260 t=(/ 2.718,2.718,2.718 /) c=(2.,3.) ch=Wolfgang
Sorties ^150^260^300^(2.000000000,3.000000000)^Wolfgang ^2.717999935^2.717999935^2.717999935

133
namelist
On peut regrouper les variables que lon dsire lire e ou crire au sein dune liste ` laquelle on donne un e a nom. Ce regroupement seectue au moyen de linstruction NAMELIST :
NAMELIST/nom_liste/liste_variables
nom liste est le nom de la NAMELIST, liste variables est une liste de variables prcdemment dclares. e e e e Au niveau de linstruction READ/WRITE la namelist remplace le format ainsi que la liste de variables qui, dans ce contexte, devient inutile. lenregistrement correspondant (lu ou crit) respecte e le format suivant :
&nom_liste liste daffectations /

134
La liste daectations concerne les variables de la namelist qui peuvent appara dans nimporte quel tre ordre, certaines pouvant tre omises. Les direntes e e aectations sont spares par des caract`res sparateurs e e e e (, ou blancs). Le caract`re / indique la n de la namelist. En e entre, les ventuels caract`res qui suivent sont ignors. e e e e En entre les cha e nes de caract`res doivent tre e e dlimites ` laide du caract`re ou ". e e a e En sortie celles-ci apparaissent par dfaut sans e dlimiteur. Cest le param`tre DELIM= de linstruction e e OPEN qui permet de le dnir. e Dans linstruction READ/WRITE, la namelist est indique ` laide du param`tre NML= (` la place de e a e a FMT=). Lutilisation des namelist est un moyen tr`s come mode deectuer des entres-sorties sans avoir ` dnir e a e de format.

135
Exemples
INTEGER i/100/, j/200/, k/300/ INTEGER t(3) CHARACTER(len=11) ch NAMELIST/LISTE/i,j,k,t,ch ... READ ( UNIT=1, NML=liste ) WRITE( UNIT=2, NML=liste ) ...
Entres e &LISTE t=3*2,i=1, k=4 ch="Rythm&Blues" / Affectations i=1,k=4,t(1)=t(2)=t(3)=2,ch="Rythm&Blues" Sorties

^&LISTE
^I=1,^J=200,^K=4,^T=2,^2,^2,^CH=Rythm&Blues
^/

Acc`s direct e
136
7.3
Acc`s direct e
` A la dirence dun chier squentiel, il est possible e e daccder ` un enregistrement dun chier ` acc`s direct e a a e sans avoir trait les prcdents. e e e Chaque enregistrement est repr par un numro ee e qui est son rang dans le chier. Leur taille est xe. Au sein de linstruction OPEN : le param`tre RECL= est obligatoire, sa valeur e indique la taille des enregistrements (en caract`res e pour les chiers textes, dpend du processeur pour e les chiers binaires), le param`tre POSITION= est invalide, e si le param`tre FORM nest pas prcis, cest la e e e valeur unformatted qui est prise en compte. Le rang de lenregistrement que lon dsire traiter e doit tre spci ` laide du param`tre REC= de e e e a e linstruction READ/WRITE. Un enregistrement ne peut pas tre dtruit mais par contre il peut tre rcrit. e e e ee Dans ce contexte, les namelist ainsi que le format libre sont interdits.

Fichier binaire ` acc`s direct a e
137
7.3.1
real, dimension(100) :: tab integer ios, n OPEN( UNIT=1, & FILE="data_bin_direct", & ACCESS="direct" , & ACTION="read", & STATUS="old", & RECL =400 ) OPEN( UNIT=2, FILE="data_txt_seq", & ACTION="read", STATUS="old" ) ... READ( UNIT=2, FMT=* ) n READ( UNIT=1, REC =n, IOSTAT=ios ) tab if ( ios < 0 ) then print *, "Lenregistrement de rang ", n, & " est inexistant" stop 4 end if if ( ios > 0 ) stop "erreur a la lecture." ` ... CLOSE( UNIT=2 ) CLOSE( UNIT=1 )

138
Le chier dont le nom est data bin direct est connect e ` lunit logique numro 1. Cest un chier binaire ` acc`s a e e a e direct (ACCESS="direct" et param`tre FORM absent donc e considr gal ` unformatted ). Chaque enregistrement fait e ee a 400 octets (RECL=400). On acc`de ` lenregistrement de rang n, valeur e a pralablement lue dans le chier texte squentiel de nom e e data txt seq connect ` lunit logique numro 2. Le paea e e ram`tre IOSTAT de linstruction READ permet de rcuprer e e e ltat de la lecture dans lentier ios : une valeur non nulle e positive signale une erreur du type enregistrement inexistant par exemple.

Fichier texte ` acc`s direct a e
139
7.3.2
real, dimension(100) :: tab integer ios, n OPEN( UNIT=1, & FILE="data_txt_direct", & FORM ="formatted" & ACCESS="direct" , & ACTION="read", & STATUS="old", & RECL =800 ) OPEN( UNIT=2, & FILE="data_txt_seq", & ACTION="read", & STATUS="old" ) READ( UNIT=2, FMT=* ) n READ( UNIT=1, REC =n, & IOSTAT=ios, FMT=(100F8.4) ) tab if ( ios < 0 ) then print *, "Lenregistrement de rang ", n, & " est inexistant" stop 4 end if if ( ios > 0 ) stop "erreur a la lecture." ` ... CLOSE( UNIT=2 ); CLOSE( UNIT=1 )

140
On a adapt lexemple prcdent ` un chier texte e e e a a ` acc`s direct : le param`tre FORM="formatted" a donc e e t prcis. ee e e La valeur du param`tre RECL correspond ` la e a taille en caract`res de chacun des enregistrements e qui correspond ici au format indiqu au niveau de e linstruction READ (100*8 = 800). Notes : il nest pas permis de lire un chier texte ` acc`s a e direct au moyen dun format libre, un chier dans lequel on crit un seul enregistree ment de rang n, contiendra en ralit n enregise e trements avec les n-1 premiers ayant un contenu indtermin. Lors de la lecture dun tel chier, se e e pose le probl`me de la reconnaissance de la nature e de celui-ci. On pourra rsoudre ce probl`me en e e adjoignant aux donnes une marque sous la forme e dune variable logique par exemple.

141
Dans lexemple suivant des enregistrements de rang alatoire sont crs. Pour les reprer on ajoute en tte e ee e e des donnes une variable logique ag. e
program dir implicit none integer, parameter :: real, dimension(n,m) :: real, dimension(n) :: integer i,j, rang, ios, logical flag
n = 100, m = 1000 matrice vec size
inquire( iolength=size ) flag, matrice(:,1) open( unit=1, & file="direct.file", & form="unformatted", & access="direct", & action="readwrite", & status="unknown", & recl=size )

142
flag = .false. do j=1,m write( unit=1, rec=j ) flag end do call random_number( matrice ) flag = .true. do j=1,m if ( matrice(1,j) > matrice(n,j) ) & write( unit=1, rec=j ) flag, matrice(:,j) end do

143
do print *,"Entrez un rang : " read( *, *, iostat=ios ) rang if ( ios < 0 ) exit if ( ios > 0 ) then print *,"Erreur de saisie. Veuillez recommencer." cycle end if read( unit=1, rec=rang, iostat=ios ) flag, vec if ( ios > 0 ) stop "Erreur lors de la lecture." if ( ios < 0 ) then print *,"Lenregistrement de rang ", n, & " nexiste pas." cycle end if if ( flag ) then print *,"vec(1) = ", vec(1), "vec(n) = ", vec(n) else print *,"Enregistrement ", rang, " indfini." e end if end do close(1) end program dir

144
Notes : linstruction inquire( iolength=size ) ... permet de rcuprer dans lentier size la taille de la liste e e de variables fournies qui servira ` renseigner, a par la suite, le param`tre RECL de linstruction e OPEN. Comme cette valeur est exprime dans e une unit dpendant du compilateur (pour les e e chiers binaires en acc`s direct), cette nouvelle e forme de linstruction inquirea , introduite par la norme Fortran 90, permet de la calculer en saranchissant de lunit, e linstruction call random_number( matrice ) fait appel ` la procdure intrins`que Fortran 90 a e e RANDOM NUMBER qui valorise le tableau transmis ` a laide de nombres alatoires gnrs dans lintervalle e e ee [0., 1.].
a cette
instruction est dtaille plus loin. e e

Fichier temporaire
145
7.4
Fichier temporaire
Si ` louverture dun chier on positionne le mota cl STATUS ` la valeur scratch alors celui-ci sera e a temporaire et dtruit ` sa fermeture. Un tel chier est e a anonyme : le param`tre FILE de linstruction OPEN ne e doit donc pas tre spci dans ce contexte. e e e
OPEN( UNIT=1, FORM="formatted" ACCESS="direct", ACTION="write", STATUS="scratch" , RECL=1200 ) ... CLOSE( UNIT=1 ) & & & & &

Destruction dun chier
146
7.5
Destruction dun chier
Linstruction CLOSE admet le param`tre ` mot-cl e a e STATUS qui par dfaut (pour un chier non temporaire) e prend la valeur KEEP permettant ainsi de conserver le chier apr`s fermeture. Si on dsire le supprimer il e e sura de prciser la valeur DELETE pour ce param`tre. e e
logical condition OPEN( UNIT=1, & FILE="data_seq", & ACTION="read", & STATUS="old" ) ... if ( condition ) then CLOSE( UNIT=1, STATUS="delete" ) else CLOSE( UNIT=1 ) end if

Fichier interne
147
7.6
Fichier interne
On appelle chier interne un chier dont les enregistrements sont en mmoire. Ce type de chier induit e des changes entre zones de la mmoire et non plus e e entre un support externe et la mmoire. e Ces chiers sont pr-connects : il ny a donc aucune e e ouverture ni fermeture ` eectuer. a Dans les instructions READ/WRITE, ` la place du a numro dunit logique on indique une variable de type e e cha de caract`res. Cest celle-ci qui fait rfrence ` ne e ee a lenregistrement en mmoire. e Seul lacc`s squentiel format est permis dans ce e e e cas. Les namelist sont interdites. Lors dune criture il faut sassurer que la cha de e ne caract`res rceptrice est de taille susante. e e Lors dune lecture, la n de chier est atteinte lorsquon essaie daccder aux caract`res situs au-del` e e e a de la cha qui fait rfrence ` lenregistrement. ne ee a

Fichier interne
148
Exemples
INTEGER, PARAMETER REAL, DIMENSION(n,m) CHARACTER(LEN=8) INTEGER :: :: :: :: n = 4, m = 6 tab fmt = "( F8.3)" i, j
WRITE( fmt(2:3) , (I2) ) n ! fichier interne OPEN( UNIT=1, & FILE="data_txt_seq", & POSITION="rewind", & ACTION="write", & STATUS="new" ) WRITE( UNIT=1, FMT=fmt ) ((tab(i,j),i=1,n),j=1,m) CLOSE( UNIT=1 )
Dans un format le facteur de rptition doit obligatoiree e ment tre prcis ` laide dune constante littrale. Cet e e ea e exemple montre comment le gnrer dynamiquement e e en utilisant un chier interne.

Fichier interne
149
PROGRAM fichier_interne CHARACTER(len=80) enreg INTEGER ios REAL x, y, z NAMELIST/liste/x, y, z OPEN( UNIT=1, FILE="data_txt_seq", & FORM="formatted", ACTION="read", & STATUS="old", POSITION="rewind" ) DO READ( UNIT=1, FMT=(a), IOSTAT=ios ) enreg if ( ios /= 0 ) exit IF ( VERIFY( enreg, & " ,+-0123456789.eEdD" ) == 0 ) THEN READ( enreg , FMT=*, iostat=ios ) x, y, z !---------------------------------------WRITE( UNIT=*, NML=liste ) END IF END DO if ( ios > 0 ) stop "Erreur lors de la lecture." CLOSE( UNIT=1 ) ... END PROGRAM fichier_interne
Dans cet exemple on lit un chier en ne traitant que les enregistrements constitus de rels et en ignorant e e tous les autres.

Instructions de positionnement
150
7.7
Toute opration de lecture-criture dans un chier e e est eectue par rapport ` la position courante dans ce e a ` chier. A louverture celle-ci peut tre prcise ` laide e e e a du param`tre POSITION. Dans un chier squentiel e e toute lecture-criture dun enregistrement de rang n e implique le positionnement ` lenregistrement de rang a n+1. Trois instructions BACKSPACE, REWIND et ENDFILE permettent de modier la position : BACKSPACE force la position au dbut de lenregise trement prcdent, e e REWIND force la position au dbut du chier, e ENDFILE crit un enregistrement de type n de e chier. Il est alors ncessaire dexcuter ensuite e e lune des deux instructions prcdentes. e e Ces instructions admettent en param`tre le numro e e de lunit logique auquel le chier est connect. e e

151
Exemple : troncature contrle dun chier oe
program troncature REAL, dimension(100) :: tab INTEGER :: ios LOGICAL :: flag = .false. OPEN( UNIT=1, FILE="data_txt_seq", ACTION="readwrite", POSITION="append", STATUS="old" ) & & & &
tab(:) = acos(-1.) WRITE( UNIT=1, FMT=(100F6.3) ) tab REWIND ( UNIT=1 )
Le chier dont le nom est data txt seq est ouvert avec un positionnement en n de chier (POSITION="append"). Apr`s criture dun enregise e trement, on se repositionne en tte (REWIND). e

152
READ( UNIT=1, FMT=(100F6.3), IOSTAT=ios ) tab DO WHILE( ios == 0 ) if ( flag ) then BACKSPACE ( UNIT=1 ) ENDFILE ( UNIT=1 ) BACKSPACE ( UNIT=1 ) END IF ... READ( UNIT=1, FMT=(100F6.3),IOSTAT=ios ) tab END DO CLOSE( UNIT=1 ) end program troncature
Ensuite on relit le chier et si la variable flag contient la valeur .TRUE. on le tronque avant le dernier enregistrement lu. (Instructions BACKSPACE et ENDFILE).

Instruction INQUIRE
153
7.8
Instruction INQUIRE
Linstruction dinterrogation INQUIRE permet de rcuprer un certain nombre dinformations concernant e e un chier ou un numro dunit logique. e e Elle permet par exemple de tester si un chier existe, sil est connect et dans ce cas de conna les valeurs e tre des param`tres positionns lors de son ouverture via e e OPEN. Cette interrogation peut tre faite en indiquant soit e le numro dunit logique soit le nom du chier. e e
program inquire LOGICAL existe INTEGER ios CHARACTER(len=3) :: form CHARACTER(len=10) :: acces INQUIRE ( FILE="data_txt_seq", EXIST=existe )

Instruction INQUIRE
154
if ( existe ) then OPEN( UNIT=1, & FILE="data_txt_seq", & POSITION="rewind", & ACTION="read", & IOSTAT=ios ) if ( ios /= 0 ) then ! erreur a louverture ` ... else INQUIRE ( UNIT=1, & FORMATTED=form, & ACCESS=acces ) end if ... CLOSE( UNIT=1 ) end if end program inquire
Dans les variables caract`res form et acces on e rcup`re respectivement les valeurs YES et SEQUENTIAL e e (si le chier data_txt_seq existe).

Remarques
155
7.9
Remarques
Les spcicateurs de format Bw[.d], Ow[.d] et Zw[.d] e permettent la conversion de donnes enti`res sous forme e e binaire, octale et hexadcimale respectivement. e
PROGRAM boz INTEGER I, J, K I = 1415; J = 1515; K = 1715 WRITE( UNIT = 1, & FMT = "(B32.32,|,O11.11,|,Z8.8)" & ) I, J, K I = -1415; J = -1515; K = -1715 WRITE( UNIT = 1, FMT=( B32.32 ) ) I WRITE( UNIT = 1, FMT=( O11.11 ) ) J WRITE( UNIT = 1, FMT=( Z8.8 ) ) K END PROGRAM boz
Sorties 00000000000000000000010110000111|00000002753|000006B3 11111111111111111111101001111001 37777775025 FFFFF94D

Remarques
156
Les chiers associs au clavier et ` lcran dune e a e session interactive sont pr-connects en gnral aux e e e e numros dunits logiques 5 et 6 respectivement : en e e lecture pour le premier, en criture pour le second. e Dans un souci de portabilit, on prfrera utiliser e ee dans les instructions READ/WRITE le caract`re * ` la e a place du numro de lunit logique pour rfrencer e e ee lentre standard (READ) ou la sortie standard (WRITE). e Cest la valeur par dfaut du param`tre UNIT. Linse e truction PRINT remplace linstruction WRITE dans le cas o` celui-ci nest pas prcis. u e e
Formes quivalentes e
CHARACTER(LEN=8) :: fmt = "(F8.3)" READ( UNIT= 5 , FMT=fmt) ... READ( UNIT= * , FMT=fmt) ... READ fmt, ... WRITE( UNIT= 6 , FMT=fmt) ... WRITE( UNIT= * , FMT=fmt) ... PRINT fmt, ...

Remarques
157
Le format ddition peut tre dni en dehors des e e e instructions dentres-sorties READ/WRITE. Dans ce cas le e param`tre FMT= est positionn ` un numro (tiquette) rene ea e e voyant ` une instruction de dnition de format (FORMAT). a e
REAL, DIMENSION(5,6) :: tab INTEGER n, i CHARACTER(len=10) :: ch ... PRINT ( I4,A,(T20,F8.3) ), & n, ch, (tab(i,:),i=1,5) PRINT 100, n, ch, (tab(i,:),i=1,5) 100 FORMAT ( I4,A,(T20,F8.3) )
En Fortran louverture dun chier squentiel est e ` e facultative. A dfaut, louverture du chier est faite implicitement lors de lexcution de la premi`re instruction e e dentre-sortie. Le compilateur attribue au chier un nom e de la forme fort.i (i tant le numro de lunit logique e e e indiqu dans linstruction READ/WRITE). Louverture est e faite en mode formatted ou unformatted suivant quun format a t ou non prcis. e e e e

Remarques
158
Le param`tre END de linstruction READ ore un autre e moyen de tester une n de chier pour un acc`s squentiel. e e On lui indique le numro (tiquette) de linstruction ` e e a laquelle on dsire poursuivre le traitement. Ce param`tre e e nest pas valide dans le cas dun chier ` acc`s direct. a e De mme, le param`tre ERR permet de se dbrancher ` e e e a une instruction dans le cas dune erreur de lecture (probl`me e de format pour un chier format, enregistrement inexistant e pour un chier ` acc`s direct ...). a e
INTEGER :: date DO PRINT *, "Saisie dune date :" READ( *, (i4), END =1, ERR =2 ) date PRINT (i4), date CYCLE PRINT *, "Saisie invalide. Veuillez recommencer." END DO PRINT *, "Arr^t de la saisie." e ...
2 1
Remarque : au clavier, la saisie du caract`re Ctrl-D e apr`s le caract`re newline (touche Enter ) indique une n e e de chier.

Remarques Remarque importante
159
Lors dune lecture, lorsquune erreur se produit (probl`me de format sagissant dun chier texte, e dtection dune n de chier ...) un traitement par e dfaut est activ par le compilateur, lequel traitement e e peut fournir des informations prcieuses quant ` la e a nature de lerreur. Lutilisation du param`tre IOSTAT e dsactive ce traitement, ce qui peut tre considr e e ee comme un inconvnient. De ce fait, pour tester une n e de chier il peut tre prfrable dutiliser le mot-cl END. e ee e Celui-ci a lavantage de ne pas masquer le traitement par dfaut concernant les erreurs ventuelles. e e
Exemple
PROGRAM lecture INTEGER date OPEN( UNIT=1, FILE="data", ACTION="read" ) DO READ( UNIT=1, FMT=(i4), END =1 ) date PRINT *, date END DO 1 CLOSE( UNIT=1 ) END PROGRAM lecture

Remarques
160
Contenu du fichier "data" 1685 1756 17a1 Sorties produites 1685 1756 "lecture.f90", line 11: 1525-097 A READ statement using decimal base input found the invalid digit a in the input file. The program will recover by assuming a zero in its place. 1701

Remarques
161
Mme exemple avec param`tre IOSTAT e e
PROGRAM lecture INTEGER date, ios OPEN( UNIT=1, & FILE="data", & ACTION="read" ) DO READ( UNIT=1, FMT=(i4), IOSTAT =ios ) date if ( ios /= 0 ) exit PRINT *, date END DO CLOSE( UNIT=1 ) if ( ios < 0 ) print *,"Fin de fichier atteinte" if ( ios > 0 ) print *,"Erreur de lecture dtecte" e e END PROGRAM lecture Sorties produites 1685 1756 Erreur de lecture dtecte e e

Plan
162
8 Procdures e
8.1 - Arguments 8.2 - Subroutines 8.3 - Fonctions 8.4 - Arguments de type cha de caract`res ne e 8.5 - Arguments de type tableau 8.6 - Arguments de type procdure e 8.7 - Procdures internes e 8.8 - Dure de vie des identicateurs e 8.9 - Procdures intrins`ques e e

Arguments
163
8.1
Arguments
Tr`s souvent, dans un programme, on a besoin e deectuer un mme traitement plusieurs fois avec e des valeurs direntes. La solution est de dnir e e ce traitement une seule fois ` laide dune unit a e de programme de type procdure (SUBROUTINE ou e FUNCTION). Les units de programmes dsirant eectuer ce e e traitement feront appel ` cette procdure en lui a e transmettant des valeurs via des variables appeles e arguments dappel (actual-arguments). La procdure e appele rcup`re les valeurs quon lui a transmises via e e e des variables appeles arguments muets (dummye arguments). En Fortran le passage de ces valeurs seectue par rfrence ; ee les adresses des arguments dappel sont transmises ` la procdure appele, a e e dans la procdure appele, les arguments muets e e sont des alias des arguments dappel.

Arguments
164
Schma passage arguments e
Fig. 1 Schma passage arguments e

Procdure appelante
arguments dappel
1 2 3 100
Procdure appele
arguments muets
real :: tab(100)
18 32.
integer :: i real :: x
real t(100) integer m real y
Stack
Adresse du tableau tab Adresse de lentier i Adresse du rel x

Subroutines
165
8.2
Subroutines
Lappel dune procdure de type SUBROUTINE sefe fectue ` laide de linstruction CALL suivie du nom de a la procdure ` appeler avec la liste des arguments e a dappels entre parenth`ses. Au sein de celle-ci linstruce tion return permet de forcer le retour ` la procdure a e appelante.
Exemple
REAL, DIMENSION(100) :: tab REAL :: moyenne, maximum ... CALL SP( tab, moyenne, maximum ) PRINT *,moyenne, maximum END SUBROUTINE SP( t, moy, max ) REAL, DIMENSION(100) :: t REAL :: moy, max INTEGER :: i max = t(1); moy = t(1) DO i=2,100 IF ( t(i) > max ) max = t(i) moy = moy + t(i) END DO moy = moy/100 END SUBROUTINE SP

Fonctions
166
8.3
Fonctions
Un autre moyen de transmettre des valeurs ` une a unit de programme est lutilisation dune procdure e e de type FUNCTION. ` A la dirence dune SUBROUTINE, une FUNCTION e retourne une valeur ; celle-ci est donc type. De plus, e son appel seectue en indiquant uniquement son nom suivi entre parenth`ses de la liste des arguments e dappels. Au sein de la fonction linstruction return sert a ` transmettre ` la procdure appelante la valeur ` a e a retourner. Celle-ci nest ncessaire que dans le cas o` e u on dsire eectuer ce retour avant la n de la dnition e e de la fonction. Dans la procdure appelante lexpression correspone dant ` lappel de la fonction est remplace par la valeur a e retourne. e

Fonctions
167
Exemple
REAL, DIMENSION(100) :: tab REAL :: moyenne, maximum REAL :: maxi ... maximum = maxi( tab, moyenne ) PRINT *,moyenne, maximum ... END FUNCTION maxi( t, moy ) REAL, DIMENSION(100) :: t REAL :: moy, maxi INTEGER :: i maxi = t(1); moy = t(1) DO i=2,100 IF ( t(i) > maxi ) maxi = t(i) moy = moy + t(i) END DO moy = moy/100 END FUNCTION maxi

Arguments de type cha de caract`res ne e
168
8.4
Lorsquune cha de caract`res est transmise en ne e argument, Fortran passe galement sa longueur de e faon implicite. c Dans la procdure appele, celle-ci peut tre e e e rcupre ` laide de la fonction intrins`que LEN. e ee a e La dclaration de la cha de caract`res au sein de e ne e la procdure appele est faite en spciant le caract`re e e e e ` la place de la longueur. a La procdure appele fait alors rfrence ` une e e ee a cha de caract`res ` taille implicite (assumed-size ne e a string).

169
Dans lexemple ci-dessous les fonctions ICHAR/ACHAR permettent de mettre en relation un caract`re et son e rang dans la table des caract`res ASCII. e
Exemple
program arg_chaine implicit none character(len=10) :: ch read (a),ch call conv( ch ) print *,ch end program arg_chaine subroutine conv( chaine ) implicit none character(len=*) :: chaine integer i, j do i=1, len (chaine) if( ichar( chaine(i:i) ichar( chaine(i:i) j = ichar( chaine(i:i) chaine(i:i) = achar( j end do end subroutine conv
) < 97 .or. & ) > 122 ) cycle ) - 32 )

Arguments de type tableau
170
8.5
Lorsque lon transmet un tableau en argument il est commode de transmettre galement ses dimensions an de e pouvoir dclarer largument muet correspondant au sein e de la procdure appele ` laide de celles-ci ; de ce fait le e e a tableau est ajustable. Exemple
program arg_tab implicit none integer, parameter :: n = 3, m = 2 real, dimension(n,m) :: tab real :: somme read *,tab; print *,somme( tab, n, m ) end program arg_tab real function somme( t, n, m ) integer :: n,m,i,j real, dimension(n,m) :: t somme = 0. do i=1,n do j=1,m somme = somme + t(i,j) end do end do end function somme

171
Lorsquun tableau est pass en argument cest ladresse e de son premier lment qui est transmise. ee La procdure appele doit possder les informations lui e e e permettant dadresser les dirents lments de ce tableau. e ee De faon gnrale, supposons que lon dispose dun c e e tableau tab ` 2 dimensions constitu de n lignes et m a e colonnes. Ladresse de llment tab(i,j) est : ee
@tab(i,j) = @tab(1,1) + [ n *(j-1)+(i-1)]*taille(lt) e
Le nombre de colonnes m nintervient pas dans ce calcul. Souvent en Fortran, lors de lappel dune procdure e seule la premi`re dimension dun tableau ` 2 dimensions est e a transmise. Dans la procdure appele celui-ci est dclar en e e e e indiquant le caract`re ` la place de la deuxi`me dimension. e a e On fait alors rfrence ` un tableau ` taille implicite ee a a (assumed-size array). Dans un tel cas, il faut faire preuve dune certaine prudence car dans la procdure appele on ne ma e e trise pas lespace mmoire total occup par le tableau. e e

172
Exemple
program taille_implicite implicit none integer, parameter :: n = 5, m = 6 real, dimension(n,m) :: tab real :: somme, som read *, tab somme = som( tab, n ) print *,somme end program taille_implicite real function som( t, lda ) implicit none integer :: lda real, dimension(lda,*) :: t integer :: i,j som = 0. do i=1,lda do j=1,lda som = som + t(i,j) end do end do end function som

Arguments de type procdure e
173
8.6
Une procdure peut tre transmise ` une autre e e a procdure. Il est ncessaire de la dclarer dans e e e la procdure appelante avec lattribut EXTERNAL ou e INTRINSIC si elle est intrins`que. e
Exemple
program arg_proc implicit none double precision b_inf, b_sup, aire double precision integrale integer pas double precision, external :: carre b_inf = 1. b_sup = 6. pas = 200000 aire = integrale( b_inf, b_sup, pas, carre ) print ("Aire : ", f11.6), aire end program arg_proc

174
function integrale( borne_i, borne_s, pas, f ) implicit none double precision borne_i, borne_s double precision integrale integer pas, i double precision h, f h = (borne_s - borne_i)/pas integrale = 0. do i=0, pas-1 integrale = integrale + h*f(borne_i+i*h) end do end function integrale function carre( x ) implicit none double precision x double precision carre carre = x*x end function carre

Procdures internes e
175
8.7
En Fortran une procdure peut en contenir e dautres. Ces procdures sont appeles procdures e e e internes. Elles ne peuvent tre appeles que depuis la e e procdure les contenant. e Les dnitions des procdures internes sont faites e e dans la procdure les incluant apr`s linstruction e e CONTAINS. Il ny a pas dimbrications possibles : une procdure e interne ne peut pas elle-mme en contenir. e
Exemple
program proc_interne implicit none character(len=10) :: ch read (a),ch call conversion( ch ) print *,ch end program proc_interne

176
subroutine conversion( chaine ) implicit none character(len=*) :: chaine integer i do i=1,len(chaine) if( ichar( chaine(i:i) ) < 97 .or. ichar( chaine(i:i) ) > 122 ) cycle chaine(i:i) = car_majuscule( chaine(i:i) ) end do CONTAINS function car_majuscule( c ) character(len=1) :: c, car_majuscule integer :: i i = ichar( c ) - (ichar(a) - ichar( A )) car_majuscule = achar( i ) end function car_majuscule end subroutine conversion

177
Dans une procdure interne, toute variable dclare e e e dans lunit de programme qui la contient est accessible, e a ` moins quelle nait fait lobjet dune redclaration. e
Exemple
program visibilite implicit none integer i, j i = 10; j = 20 call sub print ("i =",i3,", j =",i3), i, j contains subroutine sub integer j ! masque le "j" de lappelant j = 100; i = i + 1 end subroutine sub end program visibilite
Sortie
i^=^11,^j^=^20

Dure de vie des identicateurs e
178
8.8
Dure de vie et visibilit des identicateurs e e
On appelle dure de vie dun identicateur le temps e pendant lequel il existe en mmoire. Il est visible sil existe e en mmoire et est accessible, car il peut exister mais tre e e masqu par un autre de mme nom (c.f. procdure interne). e e e Par dfaut, une variable a une dure de vie limite ` e e e a celle de lunit de programme dans laquelle elle a t e e e dnie, e lattribut SAVE permet de prolonger la dure de vie e ` celle de lexcutable : on parle alors de variable a e permanente ou statique, dans une unit de programme linstruction SAVE sans e spcication de liste de variables indique que toutes les e variables de cette unit sont permanentes, e une compilation eectue en mode static force la e e prsence de linstruction SAVE dans toutes les units e de programme, ce qui implique que toutes les variables sont permanentes, par contre si elle est faite en mode stack, les variables permanentes sont : celles pour lesquelles lattribut SAVE a t prcis, e e e e celles initialises ` la dclaration (via linstruction e a e DATA ou ` laide du signe =). a

Dure de vie des identicateurs e
179
program newton double precision :: valeur = 50.d0 double precision :: tolerance double precision :: racine, x tolerance = 1.0d-1 x = racine( valeur, tolerance ) print ("Racine de ",f5.1," = ", d16.8), valeur, x tolerance = 1.0d-6 x = racine( valeur, tolerance ) print ("Racine de ",f5.1," = ", d16.8), valeur, x end program newton function racine ( valeur, tol ) double precision :: valeur, tol double precision :: racine double precision :: x = 1.0d0, x_prev integer :: nb_iterations nb_iterations = 0 do nb_iterations = nb_iterations + 1 x_prev = x x = 0.5 * (x_prev + valeur/x_prev) if ( abs(x-x_prev)/x < tol ) exit end do print *,"Nombre ditrations = ", nb_iterations e racine = x end function racine

Procdures intrins`ques e e
180
8.9
Procdures intrins`ques e e
Le compilateur Fortran dispose dune biblioth`que e de procdures couvrant dirents domaines : mathmae e e tique, conversion de type, manipulation de cha nes de caract`res, comparaison de cha e nes de caract`res, ... e Pour une procdure donne, le nom dappel di`re e e e suivant le type des arguments transmis. Un nom gnrique permet de saranchir de ces types : cest e e la solution fortement conseille car elle facilite la e portabilit. e Par exemple un appel ` la procdure gnrique a e e e ABS, retournant la valeur absolue de son argument, est transform par le compilateur en un appel ` la e a procdure : e IABS pour un argument entier, ABS pour un argument rel simple prcision, e e DABS pour un argument rel double prcision, e e CABS pour un argument complexe. Une liste des procdures intrins`ques est fournie en e e annexe B.

Plan
181
9 Common
9.1 - Linstruction Common 9.2 - Common blanc 9.3 - Common tiquet e e 9.3.1 - Initialisation : BLOCK DATA 9.3.2 - Instruction SAVE et COMMON 9.4 - R`gles et restrictions e

Linstruction COMMON
182
9.1
Linstruction COMMON
Linstruction COMMON permet le regroupement de zones mmoires pouvant tre partages par direntes units de e e e e e programme (fonctions, procdures). e La syntaxe dune instruction COMMON est la suivante : COMMON [/[nom common]/] liste variables e e e e Le COMMON est dit tiquet si nom common est prcis. Sil na pas de nom on lappelle COMMON blanc. Les direntes zones regroupes au sein du bloc COMMON e e sont adresses via des variables dont les noms sont indiqus e e dans la partie liste variables de linstruction COMMON. Pour quune unit de programme ait acc`s ` ces zones, e e a il est ncessaire quelle contienne linstruction COMMON les e rfrenant. ee c

Common blanc
183
9.2
Common blanc
Lors de la dclaration dun COMMON blanc nom common e est omis et les deux slashes / sont alors optionnels. Ses particularits sont : e un COMMON blanc est permanent (il hrite de lattribut e SAVE), les variables apparaissant dans un COMMON blanc ne peuvent pas tre initialises lors de leur dclaration. Ce e e e type de bloc est initialement constitu de bits ` 0. En e a consquence : e les donnes numriques sont initialises ` 0, e e e a les donnes logiques sont initialises ` la valeur e e a .FALSE., les donnes de type cha de caract`res reprsentent e ne e e des cha nes vides. un COMMON blanc peut ne pas avoir la mme taille e dune unit de programme ` une autre, cest alors la e a taille maximum qui sera retenue pour lensemble du programme.

Common blanc
184
Exemples
PROGRAM common_blanc INTEGER :: i INTEGER, DIMENSION(6) :: itab LOGICAL, DIMENSION(3) :: ltab COMMON itab,ltab DO i=1,6 itab(i) = i END DO ltab(1) = .true. ltab(2) = .false. ltab(3) = .true. CALL sub END PROGRAM common_blanc !************************************* SUBROUTINE sub INTEGER, DIMENSION(6) :: itab LOGICAL, DIMENSION(3) :: ltab COMMON itab,ltab PRINT*,Tableau entier = , itab PRINT*,Tableau logique = , ltab END SUBROUTINE sub

Common tiquet e e
185
9.3
Common tiquet e e
Un COMMON est dit tiquet lorsque nom common est e e prcis entre caract`res /. e e e Ses particularits sont : e il peut tre initialis par lintermdiaire dune unit de e e e e programme de type BLOCK DATA, un bloc COMMON dni dans le programme principal e reoit implicitement lattribut SAVE. Sil ne lest pas, c lattribut SAVE est ncessaire si on dsire le rendre e e permanent. Exemples
INTEGER, DIMENSION(6) :: itab REAL, DIMENSION(12) :: rtab COMMON /TAB/itab, rtab

Common tiquet e e
186
9.3.1
Initialisation : BLOCK DATA
BLOCK DATA est une unit de programme qui permet e dinitialiser des objets dclars dans des COMMONs tiquets : e e e e BLOCK DATA [nom block data] [bloc init] END BLOCK DATA [nom block data]
nom block data est le nom du BLOCK DATA bloc init est une suite : de dclarations de type (INTEGER, REAL, ...), e de dclarations de zones communes ( COMMON), e dinitialisations statiques (DATA). Un bloc COMMON ne peut appara tre que dans un seul BLOCK DATA. On peut se dnir plusieurs units BLOCK DATA, chacune e e regroupant les COMMON qui ont un lien logique entre eux.

Common tiquet e e
187
Exemples
BLOCK DATA INIT REAL :: A, B, C, D REAL, DIMENSION(10,15) :: MATRICE INTEGER, DIMENSION(20) :: VECTEUR COMMON /BLOC1/ MATRICE, A, B COMMON /BLOC2/ VECTEUR, C, D DATA A /-1./, B /3.14/, C /0./, D /7.1/ DATA MATRICE /150 * 50.0/, VECTEUR /20 * 4/ END BLOCK DATA INIT

Common tiquet e e
188
9.3.2
Instruction SAVE et COMMON
Les valeurs des variables dun COMMON tiquet dee e viennent indnies quand une procdure se termine (retour e e ` lunit appelante) sauf sil existe une autre unit de a e e programme active le rfrenant. ee c Le cas chant, on lui appliquera linstruction SAVE e e pour conserver son contenu : SAVE /nom common/ Un COMMON qui reoit lattribut SAVE dans une fonction c ou procdure devra toujours tre dclar avec ce mme e e e e e attribut dans toutes les autres units de programme, e Il est inutile de spcier lattribut SAVE si le COMMON a e t dclar dans le programme principal. e e e e

Common tiquet e e
189
Exemple
PROGRAM common_save call first call second END PROGRAM common_save !************************************* SUBROUTINE first REAL, DIMENSION(6) :: rtab LOGICAL :: drapeau COMMON /BLOC/ rtab,drapeau SAVE /BLOC/ CALL random_number(rtab) PRINT*,Afficher le tableau (true/false) READ(*,*) drapeau END SUBROUTINE first !************************************* SUBROUTINE second REAL, DIMENSION(6) :: rtab LOGICAL :: drapeau COMMON /BLOC/ rtab,drapeau SAVE /BLOC/ IF (drapeau) PRINT*,Tableau de rels e END SUBROUTINE second = , rtab

Common tiquet e e
190
9.4
R`gles et restrictions e
Un COMMON ne peut pas contenir : les noms de procdures (sous-programmes, e fonctions), les arguments de procdures, e les constantes symboliques (ayant lattribut PARAMETER). une mme variable ne peut pas appara dans 2 e tre COMMONs de noms dirents, e la taille dun bloc COMMON tiquet doit tre e e e la mme dans chaque unit de programme le e e rfrenant, ee c Fortran 90 permet dsormais le mlange de e e donnes numriques et caract`res au sein dun bloc e e e COMMON, dune unit de programme ` une autre, les variables e a de la liste peuvent porter des noms dirents, e au sein dune mme unit de programme, un bloc e e COMMON (tiquet ou non) peut tre rfrenc e e e ee e plusieurs fois : les direntes listes de variables sont e alors ajoutes les unes aux autres. e
Common tiquet e e
191
un bloc COMMON peut tre dcoup diremment e e e e dune unit de programme ` une autre, cest-`-dire e a a rfrenc ` laide de variables de types dirents ee ea e a ` condition que ce dcoupage soit cohrent (les e e zones numriques doivent correspondre ` des zones e a numriques et de mme pour les zones caract`res), e e e une instruction EQUIVALENCE ne peut pas : associer des variables dclares dans des blocs e e COMMON dirents, e avoir pour eet de prolonger le COMMON ` sa a gauche. Dans lexemple suivant, on ne peut pas associer la variable scalaire A au scalaire B(2) :
REAL :: A REAL, DIMENSION(2) :: B COMMON /X/A EQUIVALENCE (A,B(2)) EQUIVALENCE (A,B(1))
! INVALIDE ! VALIDE

Common tiquet e e Exemple

program common_mixte complex, dimension(10) :: c character(len=100) :: chaine COMMON /MIXTE/c, chaine . . . call sub end program common_mixte subroutine sub real, dimension(20) :: tab_reels character(len=1), dimension(100) :: tab_car COMMON /MIXTE/tab_reels, tab_car . . . ! impression des parties relles e print *,tab_reels(1:20:2) print *,tab_car(1), tab_car(10) end subroutine sub
192
Recommandations : 1. il est prfrable de dclarer un bloc COMMON de ee e la mme faon dans les direntes units de e c e e programme et donc demployer la technique de lexemple prcdent avec modration, e e e e 2. linstruction INCLUDE ci-apr`s favorise le bon emploi des blocs COMMON.

Plan
193
10 Include

La directive INCLUDE
194
10.1
Elle demande au compilateur dinclure un chier contenant des instructions Fortran : INCLUDE nom de fichier Exemple
PROGRAM inclusion IMPLICIT NONE INTEGER :: i INCLUDE inclusion.inc DO i=1,6 rtab(i) = PI END DO ltab(1) = .true. ltab(2) = .false. ltab(3) = .true. CALL sub END PROGRAM inclusion

195
SUBROUTINE sub IMPLICIT NONE INCLUDE inclusion.inc PRINT*,Tableau rels e = , rtab PRINT*,Tableau logique = , ltab END SUBROUTINE sub
Le chier inclusion.inc contient les dclarations de e COMMONs et de param`tres : e

DOUBLE PRECISION, PARAMETER :: PI=3.14159265d0 DOUBLE PRECISION, DIMENSION(6) :: rtab LOGICAL, DIMENSION(3) :: ltab COMMON rtab,ltab
Remarques : Linclusion du contenu du chier se fait l` o` est place a u e la directive INCLUDE, Il est possible dimbriquer plusieurs directives INCLUDE. Le nombre dimbrications possible dpend du compilae teur. La localisation du chier ` inclure peut tre prcise ` a e e e a laide de loption -I du syst`me de compilation. e

Annexe A
196
11
Annexe A : entres-sorties - syntaxes e
Entres-Sorties : syntaxes e

197
Note : les valeurs par dfaut sont soulignes. e e

Instruction OPEN
OPEN( [UNIT=]u, IOSTAT=ios, FILE=filename, STATUS=st, ACCESS=acc, FORM=form, RECL=recl, POSITION=pos, ACTION=act, BLANK=blk, DELIM=del, PAD=pad ) & & & & & & & & & & & ! ! ! ! ! ! ! ! ! ! ! ! entier entier cha^ne cha^ne cha^ne cha^ne entier cha^ne cha^ne cha^ne cha^ne cha^ne
de de de de de de de de de
caract`res e caract`res e caract`res e caract`res e caract`res e caract`res e caract`res e caract`res e caract`res e
UNIT : numro de lunit logique sur laquelle on dsire e e e connecter le chier, IOSTAT : entier valoris une fois louverture eectue. Il e e est nul si lopration sest bien passe, non nul sinon, e e FILE : nom du chier ` ouvrir, a

198
STATUS : tat du chier avant louverture, e OLD : le chier doit exister, NEW : le chier ne doit pas exister, il sera cr, ee UNKNOWN : tat dpendant du compilateur, e e REPLACE : si le chier nexiste pas, il est cr et ee hrite de ltat "OLD", sinon, il est dtruit et un e e e nouveau chier est cr, ee SCRATCH : un chier temporaire anonyme est cr, il ee sera dtruit ` la n du programme ou au moment e a du CLOSE. ACCESS : mode dacc`s au chier, e DIRECT : acc`s direct, e SEQUENTIAL : acc`s squentiel. e e

FORM : type du transfert, FORMATTED : mode caract`re (avec format), e UNFORMATTED : mode binaire (sans format).
199
RECL : longueur des enregistrements logiques en acc`s e direct ou de lenregistrement maximum en acc`s e squentiel. Lunit de longueur est le caract`re pour les e e e chiers textes et dpend du processeur pour les chiers e binaires, POSITION : positionnement dans le chier apr`s ouvere ture, ASIS : positionnement inchang si le chier est dj` e ea connect, indni sinon, e e REWIND : positionnement en tte de chier, e APPEND : positionnement en n de chier pour extension, ACTION : mode douverture. READ : seule la lecture est possible, WRITE : seule lcriture est possible, e READWRITE : la lecture ainsi que lcriture sont e permises,

200
BLANK : indique la faon dont les blancs sont interprts c e e lors dune opration dentre-sortie, e e NULL : ils sont ignors, e ZERO : ils sont interprts comme des zros, e e e DELIM : indique le caract`re dlimiteur utilis pour les e e e constantes cha nes de caract`res crites en format libre e e ou via une NAMELIST, APOSTROPHE : dlimiteur ", e QUOTE : dlimiteur , e NONE : aucun dlimiteur, e PAD : permet de grer le padding lors dune lecture, e YES : la liste de variables spcie dans linstruction e e de lecture peut tre plus grande que lenregistrement e logique, les variables non valorises lors de la lecture e sont remplies par des zros pour les variables e numriques ou logiques, par des blancs pour les e variables de type cha de caract`res, ne e NO : aucun padding nest autoris. La taille de e lenregistrement logique doit tre susante pour e permettre la valorisation des variables de la liste.

Syntaxes - READ
201
Instruction READ
READ( [UNIT=]u, [FMT=]format, [NML=]namelist, ADVANCE=ad, END=label, EOR=label, ERR=label, IOSTAT=st, REC=n, SIZE=n ) & & & & & & & & & ! ! ! ! ! ! ! ! ! ! entier cha^ne de caract`res e cha^ne de caract`res e cha^ne de caract`res e label label label entier entier entier
UNIT : numro de lunit logique sur laquelle le chier e e est connect, e FMT : format de conversion pour les chiers textes spci sous forme : e e dune constante cha de caract`res, ne e dune variable cha de caract`res, ne e dune tiquette dinstruction FORMAT. e NML : nom dune namelist,

Syntaxes - READ
202
ADVANCE : positionnement ` partir duquel seectue a lentre-sortie suivante : e YES enregistrement suivant, NO suite de lenregistrement courant, END : tiquette de linstruction ` excuter en cas de n e a e de chier, EOR : tiquette de linstruction ` excuter en cas de n e a e denregistrement, ERR : tiquette de linstruction ` excuter en cas e a e derreur, IOSTAT : entier valoris une fois lentre-sortie eectue. e e e Il est nul si lopration sest bien passe. Une valeur e e positive indique une erreur. Une valeur ngative signale e une n de chier dans le cas dun acc`s squentiel et e e labsence denregistrement du rang spci si lacc`s e e e est direct, REC : numro de lenregistrement ` traiter pour un e a chier ` acc`s direct, a e SIZE : entier rcuprant le nombre de caract`res traits e e e e si la n denregistrement a t atteinte. e e

Syntaxes - WRITE
203
Instruction WRITE
WRITE( [UNIT=]u, [FMT=]format, [NML=]namelist, ADVANCE=ad, ERR=label, IOSTAT=st, REC=n ) & & & & & & ! ! ! ! ! ! ! entier cha^ne de caract`res e cha^ne de caract`res e cha^ne de caract`res e label entier entier
UNIT : numro de lunit logique sur laquelle le chier e e est connect, e FMT : format de conversion pour les chiers textes spci sous forme : e e dune constante cha de caract`res, ne e dune variable cha de caract`res, ne e dune tiquette dinstruction FORMAT. e NML : nom dune namelist,

Syntaxes - WRITE
204
ADVANCE : positionnement ` partir duquel seectue a lentre-sortie suivante : e YES enregistrement suivant, NO suite de lenregistrement courant, ERR : tiquette de linstruction ` excuter en cas e a e derreur, IOSTAT : entier valoris une fois lentre-sortie eectue. e e e Il est nul si lopration sest bien passe, non nul sinon, e e REC : numro de lenregistrement ` traiter pour un e a chier ` acc`s direct. a e

Syntaxes - INQUIRE
205
Instruction INQUIRE
INQUIRE( [UNIT=]u, ACCESS=acc, ACTION=act, BLANK=bl, DELIM=del, DIRECT=dir, ERR=label, EXIST=ex, FILE=file, FORM=form, FORMATTED=form, IOSTAT=ios, NAME=name, NAMED=named, NEXTREC=next, NUMBER=num, OPENED=op, PAD=pad, POSITION=pos, READ=r, READWRITE=rw, RECL=n, SEQUENTIAL=seq, UNFORMATTED=un, WRITE=wr ) & & & & & & & & & & & & & & & & & & & & & & & & ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! entier cha^ne de cha^ne de cha^ne de cha^ne de cha^ne de label logique cha^ne de cha^ne de cha^ne de entier cha^ne de logique entier entier logique cha^ne de entier cha^ne de cha^ne de entier cha^ne de cha^ne de cha^ne de
caract`res e caract`res e caract`res e caract`res e caract`res e
caract`res e caract`res e caract`res e caract`res e
caract`res e caract`res e caract`res e caract`res e caract`res e caract`res e

Syntaxes - INQUIRE
206
UNIT : numro de lunit logique sur laquelle le chier e e est connect, e ACCESS : mthode dacc`s e e SEQUENTIAL si chier connect pour un acc`s e e squentiel, e DIRECT si chier connect pour un acc`s direct, e e UNDEFINED si chier non connect, e ACTION : type dacc`s e READ si chier connect en lecture, e WRITE si chier connect en criture, e e READWRITE si chier connect en lecture/criture, e e UNDEFINED si chier non connect, e BLANK : NULL si les blancs sont ignors, e ZERO si les blancs sont interprts comme des 0, e e UNDEFINED si le chier nest pas connect en mode e format ou bien nest pas connect du tout, e e

Syntaxes - INQUIRE
207
DELIM : dlimiteur pour les cha e nes de caract`res en e sortie en format libre ou via namelist APOSTROPHE dlimiteur ", e QUOTE dlimiteur , e UNDEFINED si le chier nest pas connect en mode e format ou bien nest pas connect du tout, e e DIRECT : acc`s direct e YES lacc`s direct est un mode dacc`s permis, e e NO lacc`s direct nest pas un mode dacc`s permis, e e UNKNOWN le compilateur ne sait pas si lacc`s direct e est permis ou non, ERR : tiquette de linstruction ` excuter en cas e a e derreur, EXIST : .true. si le chier ou lunit logique existe, e .false. si le chier ou lunit logique nexiste pas, e FILE : nom du chier pour lequel on souhaite avoir des informations,

Syntaxes - INQUIRE
208
FORM : type dacc`s e FORMATTED si le chier est connect en mode format, e e UNFORMATTED si le chier est connect en mode e binaire, UNDEFINED si le chier nest pas connect, e FORMATTED : YES si le traitement du chier en mode format est e valide NO si le traitement du chier en mode format nest e pas valide, UNKNOWN lorsque le compilateur ne sait pas si le traitement du chier en mode format est permis e ou non, IOSTAT : valeur de retour > 0 si une erreur sest produite, = 0 si aucune erreur ne sest produite, NAME : nom du chier connect sil a un nom, sinon e valeur indnie, e

Syntaxes - INQUIRE
209
NAMED : .true. si le chier a un nom, .false. si le chier est anonyme, NEXTREC : renvoie le numro du prochain enregistrement ` e a traiter si le chier est ouvert en acc`s direct (1 si e aucun enregistrement na dj` t trait, eae e e renvoie une valeur indnie si le chier na pas t e e e ouvert en acc`s direct, e NUMBER : renvoie le numro de lunit logique sur e e laquelle le chier est connect (-1 sil ne lest pas), e OPENED : .true. si le chier est ouvert, .false. si le chier nest pas ouvert, PAD : NO le chier a t ouvert avec le param`tre PAD=NO, e e e YES le chier a t ouvert avec le param`tre PAD=YES e e e ou bien le chier nest pas connect, e

Syntaxes - INQUIRE POSITION :
210
REWIND si chier ouvert avec un positionnement en tte, e APPEND si chier ouvert avec un positionnement en n, ASIS si chier ouvert sans changement de la position, UNDEFINED si chier non connect ou bien connect e e en acc`s direct, e READ : YES un acc`s en lecture est permis, e NO un acc`s en lecture nest pas permis, e UNKNOWN le compilateur ne sait pas si un acc`s en e lecture est permis ou non, READWRITE : YES un acc`s en lecture/criture est permis, e e NO un acc`s en lecture/criture nest pas permis, e e UNKNOWN le compilateur ne sait pas si un acc`s en e lecture/criture est permis ou non, e RECL : renvoie la taille de lenregistrement logique maximum ou une valeur indnie si le chier nexiste e pas,

Syntaxes - INQUIRE
211
SEQUENTIAL : YES lacc`s squentiel est un mode dacc`s permis, e e e NO lacc`s squentiel nest pas un mode dacc`s e e e permis, UNKNOWN le compilateur ne sait pas si lacc`s e squentiel est permis ou non, e UNFORMATTED : YES si le traitement du chier en mode binaire est valide NO si le traitement du chier en mode binaire nest pas valide, UNKNOWN lorsque le compilateur ne sait pas si le traitement du chier en mode binaire est permis ou non, WRITE : YES un acc`s en criture est permis, e e NO un acc`s en criture nest pas permis, e e UNKNOWN le compilateur ne sait pas si un acc`s en e criture est permis ou non. e

Syntaxes - CLOSE
212
Instruction CLOSE
CLOSE( [UNIT=]u, IOSTAT=ios, STATUS=st ) & &
UNIT : numro de lunit logique du chier ` fermer, e e a IOSTAT : entier valoris une fois la fermeture e eectue. Il est nul si lopration sest bien passe, e e e non nul sinon, STATUS : tat du chier apr`s fermeture, e e DELETE : le chier est dtruit apr`s fermeture. e e Cest la valeur par dfaut si louverture a t e ee faite avec le param`tre STATUS=scratch, e KEEP : le chier est conserv apr`s fermeture. e e Cest la valeur par dfaut si louverture a t e ee faite avec le param`tre STATUS dirent de e e scratch.

Syntaxes - CLOSE
213
Exemples
integer ios ... OPEN ( UNIT =1, & FILE ="donnees", & FORM ="unformatted", & ACTION ="read", & POSITION ="rewind", & IOSTAT =ios ) if ( ios /= 0 ) ! Probl`me a louverture e ` ... CLOSE ( UNIT =1 ) OPEN ( UNIT =2, & FORM ="formatted", & ACCESS ="direct", & STATUS ="scratch", & ACTION ="write", & LRECL =9600, & IOSTAT =ios ) if ( ios /= 0 ) ! Probl`me a louverture e ` ... CLOSE ( UNIT =2 )

Annexe B
214
12
Annexe B : procdures intrins`ques e e
Principales procdures intrins`ques e e

Principales procdures intrins`ques e e 215

Principales procdures intrins`ques lmentaires e e ee
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.)) = 5.0
ACHAR : retourne le caract`re de la table ASCII dont e le rang est transmis en argument.
ACHAR(88) = X; ACHAR(42) = *
ACOS : retourne larc cosinus en radians de son argument rel. e

ACOS(0.54030231) = 1.0
ADJUSTL : cadre ` gauche la cha passe en a ne e argument : supprime les blancs en tte ; compl`te e e a ` droite par des blancs.
ADJUSTL(^^Fortran) = Fortran^^
ADJUSTR : cadre ` droite la cha passe en a ne e argument : supprime les blancs en n ; compl`te a e ` gauche par des blancs.
ADJUSTR(Fortran^^) = ^^Fortran

AIMAG : retourne la partie imaginaire du complexe pass en argument. e

AIMAG((2.,3.)) == 3.0
AINT : tronque le rel pass en argument. e e

AINT(2.783) = 2.0; AINT(-2.783) = -2.0
ANINT : retourne, sous forme dun rel, lentier le e plus proche du rel transmis. e
ANINT(2.783) = 3.0; ANINT(-2.783) = -3.0
ASIN : retourne larc sinus en radians de son argument rel. e

ASIN(0.84147098) = 1.0
ATAN : retourne larc tangente en radians de son argument rel. e

ATAN(1.5574077) = 1.0
BIT SIZE : retourne le nombre de bits utiliss pour e la reprsentation de lentier pass en argument. e e
BIT_SIZE(1) = 32


BTEST : permet de tester la valeur dun bit dun entier : lentier ainsi que la position du bit ` tester a sont passs en argument. e
BTEST(8,3) = .true.; BTEST(10,2) = .false.
CEILING : retourne lentier immdiatement suprieur e e au rel transmis en argument. e

CEILING(3.7) = 4, CEILING(-3.7) = -3
CMPLX : retourne un complexe dont les parties relle e et imaginaire sont transmises en argument.
CMPLX(-3.) = -3.0+0.i; CMPLX(2,4.) = 2.0+4.0i
CONJG : retourne le complexe conjugu de celui e pass en argument. e

CONJG((-3.0,4.0)) = -3.0-4.0i
COS : retourne le cosinus de langle pass en e argument (exprim en radians). e

COS(1.0) = 0.54030231
COSH : retourne le cosinus hyperbolique.

COSH(1.0) = 1.5430806


DBLE : convertit en double prcision largument e transmis. EXP : retourne lexponentiel de largument transmis.
EXP(1.0) = 2.7182818
FLOOR : retourne lentier immdiatement infrieur e e au rel transmis en argument. e

FLOOR(3.7) = 3, FLOOR(-3.7) = -4
IACHAR : retourne le rang dans la table ASCII du caract`re transmis en argument. e

IACHAR(X) = 88; IACHAR(*) = 42
IAND : retourne lentier dont la reprsentation e binaire est obtenue en combinant ` laide dun a et logique les bits des deux entiers transmis en argument.
IAND(1,3) = 1; IAND(10,10) = 10
IBCLR : permet de forcer ` zro un bit dun entier : a e lentier ainsi que la position du bit ` forcer sont a passs en argument. e
IBCLR(14,1) = 12 IBCLR((/ 1,2,3,4 /), 31) = (/ 29,27,23,15 /)


IBITS : permet lextraction dune squence de bits e dun entier. Lentier suivi de la position ainsi que la longueur pour eectuer lextraction sont passs e en argument.
IBITS(14,1,3) = 7
IBSET : permet de forcer ` 1 un bit dun entier : a lentier ainsi que la position du bit ` forcer sont a passs en argument. e
IBSET(12,1) = 14 IBSET((/ 1,2,3,4 /), 0) = (/ 1,3,3,5 /)
IEOR : retourne lentier dont la reprsentation e binaire est obtenue en combinant ` laide dun a ou exclusif les bits des deux entiers transmis en argument.
IEOR(1,3) = 2; IEOR(10,10) = 0
INDEX : retourne la position dune sous-cha dans ne une cha ne. La cha suivie de la sous-cha et ne ne du sens de la recherche sont fournis en argument.
INDEX(FORTRAN,R) = 3 INDEX(FORTRAN,R,BACK=.true.) = 5


INT : convertit en entier largument transmis.
INT(-3.7) = -3; INT(9.1/4.0) = 2
IOR : retourne lentier dont la reprsentation binaire e est obtenue en combinant ` laide dun ou logique a les bits des deux entiers transmis en argument.
IOR(1,3) = 3 IOR((/ 3,2 /),(/ 1,10 /)) = (/ 3,10 /)
ISHFT : permet deectuer un dcalage des bits de e lentier pass en premier argument. Le deuxi`me e e argument indique le nombre de bits ` dcaler : son a e signe indique le sens du dcalage (positif = gauche, e ngatif = droite). Les bits sortants sont perdus, les e positions vacantes sont mises ` zro. a e
ISHFT(3,1) = 6; ISHFT(3,-1) = 1
ISHFTC : idem ISHFT ` la dirence que le dcalage a e e est circulaire et seectue sur les n bits de droite de lentier , n tant fourni en troisi`me argument e e (sil est absent il est considr gal au nombre de eee bits de lentier).
ISHFT(3,2,3) = 5; ISHFT(3,-2) = -1073741824

LEN : retourne la longueur de la cha de caract`res ne e transmise en argument.

CHARACTER(len=10) CH; LEN(CH) = 10
LEN TRIM : retourne la longueur de la cha de ne caract`res transmise en argument sans considrer e e les blancs de n.
LEN_TRIM(^^FORTRAN^^^) = 9; LEN_TRIM(^^^) = 0
LGE : compare les deux cha nes de caract`res e transmises en argument : retourne .true. si la premi`re cha est suprieure ou gale ` la e ne e e a deuxi`me, .false. sinon. e
LGE(MANET,MONET) = .false. LGE(MANET Edouard,MANET) = .true.
LGT : compare les deux cha nes de caract`res e transmises en argument : retourne .true. si la premi`re cha est suprieure strictement ` la e ne e a deuxi`me, .false. sinon. e
LGT(MANET,MANET) = .false.


LLE : compare les deux cha nes de caract`res e transmises en argument : retourne .true. si la premi`re cha est infrieure ou gale ` la e ne e e a deuxi`me, .false. sinon. e
LLE(MANET,MONET) = .true. LLE(MANET,MANET) = .true.
LLT : compare les deux cha nes de caract`res e transmises en argument : retourne .true. si la premi`re cha est infrieure strictement ` la e ne e a deuxi`me, .false. sinon. e
LLT(MANET,MANET) = .false.
LOG : retourne le logarithme nprien de largument e e transmis.

LOG(2.7182818) = 1.0; LOG(10.0) = 2.3025851
LOG10 : retourne le logarithme dcimal de largue ment transmis.

LOG10(10.0) = 1.0; LOG10(10.E10) = 11.0
MAX : retourne le maximum des nombres passs en e argument.

MAX(-9.0,7.0,2.0) = 7.0


MIN : retourne le minimum des nombres passs en e argument.
MIN(-9.0,7.0,2.0) = -9.0
MOD : retourne le reste de la division eectue a e ` laide des deux arguments fournis.
MOD(3.0,2.0) = 1.0; MOD(-8,5) = -3
NOT : retourne lentier dont la reprsentation binaire e est obtenue en inversant les bits de lentier transmis en argument.
NOT(10) = -11
REAL : convertit en rel largument transmis. e

REAL(3) = 3.0
REPEAT : permet de concatner n fois une cha de e ne caract`res. e

REPEAT(A,10) = AAAAAAAAAA
SCAN : retourne la position du premier caract`re e dune cha gurant parmi un ensemble de cane ract`res donn. La recherche peut tre faite dans e e e les deux sens.
SCAN(RENOIR,OI) = 4 SCAN(RENOIR,OI,BACK=.true.) = 5


SIGN : retourne le nombre dont la valeur absolue est celle du premier argument et le signe celui du deuxi`me. e
SIGN(-3.0,2.0) = 3.0
SIN : retourne le sinus de langle pass en argument e (exprim en radians). e

SIN(1.0) = 0.84147098
SINH : retourne le sinus hyperbolique.

SINH(1.0) = 1.1752012
SQRT : retourne la racine carr de son argument. e

SQRT(5.0) = 2.236068010
TAN : retourne la tangente de langle pass en e argument (exprim en radians). e

TAN(1.0) = 1.5574077
TANH : retourne la tangente hyperbolique.

TANH(1.0) = 0.76159416
TRIM : retourne la cha de caract`res transmise ne e dbarrasse de ses blancs de n. e e

TRIM(PICASSO^^^^^) = PICASSO

VERIFY : retourne la position du premier caract`re e dune cha ne gurant pas parmi un ensemble de ne caract`res donn. La recherche peut tre faite dans e e e les deux sens.
VERIFY(RENOIR,OI) = 1 VERIFY(RENOIR,OI,BACK=.true.) = 6

Annexe C
226
13
Annexe C : aspects obsol`tes e
Aspects obsol`tes e

Aspect obsol`tes e
227
Aspects obsol`tes e
1. IF arithmtique : IF (ITEST) 10,11,12 e ==> IF--THEN--ELSE IF--ELSE--ENDIF 2. Branchement au END IF depuis lextrieur (*) e ==> se brancher a linstruction suivante. ` 3. Boucles DO pilotes par rels : DO 10 R=1., 5.7, 1.3 (*) e e 4. Partage dune instruction de n de boucle : DO 1 I=1,N DO 1 J=1,N A(I,J)=A(I,J)+C(J,I) 1 CONTINUE ==> autant de CONTINUE que de boucles. 5. Fins de boucles autres que CONTINUE ou END DO 6. ASSIGN et le GO TO assign : (*) e ASSIGN 10 TO intvar .... ASSIGN 20 TO intvar .... GO TO intvar ==> SELECT CASE ou IF/THEN/ELSE (*) : aspects obsol`tes dclars hors norme par Fortran 95 e e e

Aspect obsol`tes e
228
7. ASSIGN dune tiquette de FORMAT : (*) e ASSIGN 2 TO NF 2 FORMAT (F9.2) PRINT NF,TRUC 8. RETURN multiples : CALL SP1(X,Y,*10,*20) ... 10 ... ... 20 ... ... SUBROUTINE SP1(X1,Y1,*,*) ... RETURN 1 ... RETURN 2 ... ==> SELECT CASE sur la valeur dun argument retourn e 9. PAUSE Montez la bande 102423 SVP (*) ==> READ qui attend les donnes e 10. FORMAT(9H A eviter) (*) ==> Constante littrale : FORMAT( Recommand) e e (*) : aspects obsol`tes dclars hors norme par Fortran 95 e e e CHARACTER(7),DIMENSION(4)::C I = 2; C(2) = (F9.2) PRINT C(I),TRUC
==>

Aspect obsol`tes e
229
Aspects obsol`tes introduits par Fortran 95 : e
1. Le " format fixe " du source ==> "format libre". 2. Le GO TO calcul (GO TO (10,11,12,...), int expr) e ==> select case. 3. Linstruction DATA place au sein des instructions excutables e e ==> avant les instructions excutables. e 4. Statement functions (sin deg(x)=sin(x*3.14/180.)) ==> procdures internes. e 5. Le type CHARACTER* ... dans les dclarations e ==> CHARACTER(LEN=...) 6. Le type CHARACTER(LEN=*) de longueur implicite en retour dune fonction ==> CHARACTER(LEN=len(str)).

Annexe D
230
14
Annexe D : syst`me de compilation e
Syst`me de compilation e

231
La commande f90 permet de gnrer un excutable a partir de e e e ` chiers sources Fortran. Celle-ci appelle un syst`me de compilation faisant successivement e appel a : ` un prprocesseur, e un compilateur, un loader ou diteur de liens. e La composante prprocesseur transforme le source Fortran en e entre au moyen de directives. e La composante compilateur analyse le source Fortran fourni (ventuellement transform a ltape prcdente) avec : e e` e e e dtection des erreurs de syntaxe, e traduction du source en langage machine plus ou moins optimis, e production dun module objet. Enn la derni`re composante fait appel au loader qui rcup`re e e e les modules objets prcdemment crs et les regroupe pour produire e e ee un module excutable. e Les direntes units de programme constituant une application e e Fortran peuvent gurer dans un mme chier ou bien tre rparties e e e dans plusieurs chiers. Ceux-ci doivent tre suxs par .f ou .f90 . e e

232
Le compilateur suppose que le source est crit avec le format xe e si le chier est sux par .f et avec le format libre si le chier est e e e e sux par .f90 . Ce format dcriture peut tre explicit au moyen e dune option indpendamment du suxe employ. e e Les chiers correspondant aux modules objets sont suxs par e .o . Par dfaut le module excutable est stock dans un chier e e e de nom a.out quil est possible de renommer a laide de loption ` -o nom excutable dsir . e e e Loption -c permet de conserver le ou les modules objets produits par le compilateur et dinhiber ltape du loader. e Cest la technique employe par lutilitaire make qui, autoe matiquement, lance les compilations des dirents chiers source e constituant lapplication. Les modules objets obtenus sont in ne fournis au syst`me de compilation pour la production du module e excutable. e
Exemple
$ f90 -c source1.f90 $ f90 -c source2.f90 ... $ f90 -c sourcen.f90 $ f90 *.o -o a.exe

233
Il est possible darchiver les chiers *.o a laide de lutilitaire ar ` dans le but de les regrouper dans un seul chier dont le nom est de la forme libxxx.a . Cela permet la constitution de biblioth`ques de modules objets e lesquelles sont transmises a la composante loader a laide des options ` ` -L et -l permettant de spcier lendroit o` celles-ci sont stockes e u e et leur noms.
Exemple
$ f90 -c source1.f90 $ f90 -c source2.f90 ... $ f90 -c sourcen.f90 $ ar -rv libexemple.a *.o $ mv libexemple.a $HOME/lib $ f90 -L$HOME/lib -lexemple -o a.exe

Annexe E
234
15
Annexe E : exercices
E.1 Exercices : noncs e e E.2 Exercices : corrigs e

Enoncs e Exercice 1
235
Ecrire un programme permettant de rsoudre le syst`me de e e 2 quations a 2 inconnues : e `
u1 x + v1 y = w1 u2 x + v2 y = w2
On pourra imprimer les solutions a laide de linstruction : ` PRINT *, X = , X, , Y = , Y
Exercice 2
Ecrire un programme permettant de calculer les racines du trinme du 2nd degr : ax2 + bx + c. On sassurera que a est o e non nul. Les racines, si elles existent, pourront tre imprimes a e e ` laide de linstruction : PRINT *, X1 = , X1, , X2 = , X2
Exercice 3
Ecrire un programme calculant le nombre dOr. Celui-ci peut tre obtenu a partir de la suite de Fibonnacci un dnie par : e ` e u0 = 1 u1 = 1 ... un+1 = un + un1 La suite (
un+1 ) un
converge vers le nombre dOr.

Enoncs e Exercice 4
236
Ecrire un programme permettant de dterminer les nombres e premiers dans lintervalle [1,n] a laide du crible dEratosth`ne. Il ` e consiste a former une table avec tous les entiers naturels compris ` entre 2 et n et a rayer (mise a zro), les uns apr`s les autres, les ` ` e e entiers qui ne sont pas premiers de la mani`re suivante : d`s que e e lon trouve un entier qui na pas encore t ray, il est dclar e e e e e premier, et on raye tous les multiples de celui-ci. ` A la n du procd, les nombres non barrs sont des nombres e e e premiers. On tiendra compte du fait quun nombre donn peut dj` e ea avoir t limin en tant que multiple de nombres prcdents e e e e e e dj` tests. ea e Par ailleurs, on sait que lon peut rduire la recherche aux e nombres de 2 a n (si un entier non premier est strictement ` e ` suprieur a n alors il a au moins un diviseur infrieur a n et e ` aura donc dj` t ray). eae e e
Exercice 5
Ecrire un programme permettant de trier un vecteur de nombres en ordre croissant puis dcroissant. On sappuiera sur e lalgorithme appel tri ` bulle qui consiste a comparer 2 lments e a ` ee conscutifs et a les intervertir si ncessaire. e ` e Si apr`s avoir termin lexploration du tableau au moins une e e interversion a t eectue, on renouvelle lexploration, sinon le e e e tri est termin. e

Enoncs e
237
Exercice 6
Ecrire un programme permettant deectuer le produit de 2 matrices A et B. Leurs prols seront dnis a laide de constantes e ` symboliques. La matrice rsultat C sera imprime a lcran ligne e e ` e par ligne avec linstruction PRINT puis stocke dans un chier e binaire que lon nommera exo6.matrice .
Exercice 7
Le chier texte squentiel musiciens est constitu de e e plusieurs enregistrements, chacun contenant un nom de musicien suivi de ses annes de naissance et de mort. e Ecrire un programme dont le but est de lire le chier musiciens et de stocker les enregistrements lus dans un chier binaire a acc`s direct que lon nommera musiciens.bin . ` e
Exercice 8
Imprimer lenregistrement du chier musiciens dont le rang est entr au clavier. Son extraction sera eectue a partir e e ` dun chier temporaire a acc`s direct, image du prcdent. ` e e e On permettra la saisie de plusieurs rangs.

Enoncs e
238
Exercice 9
Les enregistrements des chiers squentiels e index naissance.dat et index deces.dat sont constitus e dune date de naissance (ou de dc`s) dun musicien suivi de son e e rang dans le chier musiciens.bin cr a lexercice 7. ee ` Ecrire un programme permettant dimprimer le ou les musiciens dont la date de naissance ou de mort est saisie au clavier. Le type de date dsire sera pralablement dtermin. e e e e e La slection des enregistrements rpondant aux choix e e spcis, seectuera par lintermdiaire du chier dindex e e e correspondant au type de date. On orira la possibilit deectuer plusieurs recherches. e
Exercice 10
Le but de cet exercice est de transformer la matrice stocke e dans le chier binaire exo6.matrice . Cette transformation consiste a modier chaque lment a laide dune fonction ` ee ` paramtrable de la forme y = f (x). e On dnira plusieurs fonctions de ce type. La valeur dun e entier lu dans une namelist indiquera la fonction a transmettre en ` argument de la procdure charge deectuer la transformation. e e

Enoncs e
239
Exercice 11
Trier les vecteurs lignes puis les vecteurs colonnes dune matrice en utilisant lalgorithme tri ` bulle et la matrice stocke a e dans le chier binaire exo6.matrice . On se dnira une procdure eectuant le tri (croissant ou e e dcroissant) des dirents vecteurs au moyen dune procdure e e e interne.

Corrigs e
240
Corrig de lexercice 1 e
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
program systeme implicit none real u1,u2 real v1,v2 real w1,w2 real delta, delta_x, delta_y real x,y ! Valorisation des coefficients. u1 = 2; u2 = 4 v1 = 5; v2 = 11 w1 = 7; w2 = 6 ! Calcul du dterminant principal. e delta = u1*v2 - u2*v1 if ( delta == 0. ) then print *, "Le syst`me na pas de solution unique." e stop 4 end if ! Calcul du dterminant en x. e delta_x = w1*v2 - w2*v1 ! Calcul du dterminant en y. e delta_y = u1*w2 - u2*w1 ! calcul des solutions. x = delta_x/delta y = delta_y/delta ! Impression des solutions. print *, "x = ", x, ", y = ", y end program systeme

Corrigs e
241
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program trinome implicit none real a, b, c real delta, r_delta, x1, x2 ! Valorisation des coefficients. a = 3.; b = 7.; c = -11. ! a doit etre non nul. ^ if ( a == 0. ) stop "a doit etre non nul." ^ ! calcul du dterminant. e delta = b*b - 4*a*c ! cas du dterminant ngatif. e e if( delta < 0. ) stop "Pas de racine relle." e ! cas du dterminant nul. e if ( delta == 0. ) then x1 = -b/(2*a); x2 = x1 else ! cas du dterminant positif. e r_delta = sqrt( delta ) x1 = (-b - r_delta)/(2*a); x2 = (-b + r_delta)/(2*a) end if ! Impression des racines. print *,"x1 = ", x1, ", x2 = ", x2 end program trinome

Corrigs e
242
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program nombre_dor implicit none real, parameter :: real :: real :: real :: real ::
epsilon = 1.e-5 u_prec, u_cour v_prec, v_cour somme nombre_or
nombre_or = (1. + 5.**0.5)/2. u_prec = 1.; u_cour = 1. do v_prec = u_cour/u_prec somme = u_cour + u_prec u_prec = u_cour u_cour = somme v_cour = u_cour/u_prec if ( abs( (v_cour-v_prec)/v_prec ) < epsilon ) exit end do print*, "Limite de la suite (vn) : ", v_cour, & "Nombre dor : ", nombre_or end program nombre_dor

Corrigs e
243
Corrig de lexercice 3 (autre solution) e
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program nombre_dor implicit none double precision, parameter :: epsilon = 1.d-11 double precision :: u_prec, u_cour double precision :: v_cour double precision :: somme double precision :: nombre_or ! Attention : une partie de lexpression suivante est ! --------evalue en simple prcision. Ce qui fait e e ! diverger le calcul itratif qui suit! e !nombre_or = (1.d0 + 5.**0.5)/2.d0 nombre_or = (1.d0 + 5.d0**0.5d0)/2.d0 u_prec = 1.d0; u_cour = 1.d0 do somme = u_cour + u_prec u_prec = u_cour u_cour = somme v_cour = u_cour/u_prec if ( abs( (v_cour-nombre_or) < epsilon ) exit end do print*, "Limite de la suite (vn) : ", v_cour, & "Nombre dor : ", nombre_or end program nombre_dor

Corrigs e
244
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program eratosthene implicit none integer, parameter :: n = 1000 integer, dimension(n) :: tab_nombres integer :: imax integer i, j do i=2,n tab_nombres(i) = i end do imax = int(sqrt(real(n))) do i=2,imax if( tab_nombres(i) /= 0 ) then do j=i+1,n if ( tab_nombres(j) /= 0 .and. & mod( tab_nombres(j), i ) == 0 ) & tab_nombres(j) = 0 end do end if end do print *,"Les nombres premiers entre 1 et ", n, " sont :" do i=2,n if ( tab_nombres(i) /= 0 ) print *,tab_nombres(i) end do end program eratosthene

Corrigs e Corrig de lexercice 5 e

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
245
program triabulle implicit none integer, parameter real, dimension(n) real logical integer
:: :: :: :: ::
croissant=1, decroissant=2, n=10 tab temp tri_termine, expr1, expr2 sens, i
! Valorisation du vecteur data tab/0.76, 0.38, 0.42, 0.91, 0.25, & 0.13, 0.52, 0.69, 0.76, 0.98/ do sens=croissant, decroissant ! Sens du tri do ! Tri tri_termine = .true. do i=2,n expr1 = sens == croissant .and. tab(i-1) > tab(i) expr2 = sens == decroissant .and. tab(i-1) < tab(i) if (expr1 .or. expr2) then tri_termine = .false. temp = tab(i-1); tab(i-1) = tab(i); tab(i) = temp end if end do if (tri_termine) exit end do ! Impression du vecteur tri e if (sens == croissant) print*, "Tri croissant " if (sens == decroissant) print*, "Tri dcroissant " e print*, tab end do end program triabulle

Corrigs e
246
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program produit_matrice implicit none integer, parameter :: real, dimension(n,m) :: real, dimension(m,p) :: real, dimension(n,p) :: integer ::
n = 10, m = 5, p = 3 a b c i,j,k A et B & & & & & & & & & &
data
! Valorisation des matrices ((a(i,j),j=1,m),i=1,n)/ 0.00, 0.38, 0.42, 0.91, 0.25, 0.13, 0.52, 0.69, 0.76, 0.98, 0.76, 0.83, 0.59, 0.26, 0.72, 0.46, 0.03, 0.93, 0.05, 0.75, 0.53, 0.05, 0.85, 0.74, 0.65, 0.22, 0.53, 0.53, 0.33, 0.07, 0.05, 0.67, 0.09, 0.63, 0.63, 0.68, 0.01, 0.65, 0.76, 0.88, 0.68, 0.38, 0.42, 0.99, 0.27, 0.93, 0.07, 0.70 ,0.37, 0.44/ & & & & &
data ((b(i,j),j=1,p),i=1,m)/ 0.76, 0.16, 0.9047, 0.47, 0.48, 0.5045, 0.23, 0.89, 0.5163, 0.27, 0.90, 0.3190, 0.35, 0.06, 0.9866/

Corrigs e
247
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
! Produit de matrice. do i=1,n do j=1,p c(i,j) = 0. do k=1,m c(i,j) = c(i,j) + a(i,k) * b(k,j) end do end do end do ! Impression de la matrice c. do i=1,n print *, c(i,:) end do ! criture de la matrice c dans un fichier. E open( unit=1, file="exo6.matrice", & status="replace", form="unformatted", & action="write" ) write( unit=1 ) c close( unit=1 ) end program produit_matrice

Corrigs e
248
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
program ecriture_musiciens character(len=80) :: mus integer :: ios_mus, lrecl integer :: numrec ! ! ! ! Ouverture du fichier des musiciens ainsi que dun fichier en ecriture a acc`s direct dans lequel on ` e va recopier le fichier prcdent. e e open( unit=1, file="musiciens", & form="formatted", status="old", & action="read", position="rewind" ) ! Calcul de la taille des enregistrements du fichier ! binaire en sortie. (dpend du compilateur). e inquire( iolength=lrecl ) mus open( unit=2, file="musiciens.bin", & status="replace", & form="unformatted", access="direct", & action="write", recl=lrecl ) ! On effectue la copie. numrec = 0 read( unit=1, fmt=(a), iostat=ios_mus ) mus do while ( ios_mus == 0 ) numrec = numrec + 1 write( unit=2, rec=numrec) mus read( unit=1, fmt=(a), iostat=ios_mus ) mus end do close( unit=1 ); close( unit=2 ) if ( ios_mus > 0 ) print *,"Erreur lecture sur lunit 1." e end program ecriture_musiciens

Corrigs e
249
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
program musiciens implicit none integer, parameter character(len=lrecl) integer integer ! ! ! !
:: :: :: ::
lrecl=80 mus ios_mus, ios_stdin numrec, rang
Ouverture du fichier des musiciens ainsi que dun fichier temporaire a acc`s direct dans lequel on ` e va recopier le fichier prcdent. e e open( unit=1, file="musiciens", form="formatted", status="old", action="read", position="rewind" ) open( unit=2, status="scratch", form="formatted", access="direct", action="readwrite", recl=lrecl ) ! On effectue la copie. numrec = 0 do read( unit=1, fmt=(a), END=1 ) mus numrec = numrec + 1 write( unit=2, rec=numrec, fmt=(a) ) mus end do 1 close( unit=1 )
& & & &

Corrigs e
250
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
! On demande un rang de musicien. do print *,"Entrez le rang dun musicien :" read( unit=*, fmt=*, iostat=ios_stdin ) rang do while ( ios_stdin == 0 ) read( unit=2, rec=rang, fmt=(a), iostat=ios_mus ) mus if ( ios_mus /= 0 ) then print *,"Le musicien de rang ", & rang, "nexiste pas" else print ("musicien de rang",i3," ==> ", a), & rang,trim(mus) end if print *,"Entrez le rang dun musicien :" read( unit=*, fmt=*, iostat=ios_stdin ) rang end do if ( ios_stdin > 0 ) then print (a,/),"Erreur lors de la saisie." else exit end if end do close( unit=2 ) end program musiciens

Corrigs e
251
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program sequentiel_indexe implicit none character(len=19), dimension(2), parameter :: f_index = & (/ "index_naissance.dat", "index_deces.dat " /) character(len=80) :: mus character(len=50) :: prompt_date integer :: numrec, ios_stdin integer :: date_saisie, date_lue integer :: critere, lrecl logical :: trouve ! Ouverture du fichier des musiciens a acc`s direct en lecture ` e ! et des fichiers dindex. open ( unit=1, file = f_index(1), & status="old", form="formatted", action="read" ) open ( unit=2, file = trim(f_index(2)), & status="old", form="formatted", action="read" ) ! Calcul de la taille des enregistrements du fichier ! cre a lexercice 7. (dpend du compilateur). e ` e inquire( iolength=lrecl ) mus open ( unit=3, file="musiciens.bin", & status="old", form="unformatted", & access="direct", action="read", recl=lrecl )

Corrigs e
252
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
trait: & do do print*,-------------------------------- print*,Choix du crit`re de recherche : e print*,- par date de naissance (1) print*,- par date de dc`s e e (2) print*,- QUITTER (3) print*,-------------------------------- read(*, *, IOSTAT=ios_stdin) critere if ( ios_stdin < 0 ) exit trait if ( ios_stdin > 0 ) then print (/,a,/), "Erreur dans la saisie" else exit end if end do select case (critere) case(1) ! Recherche par date de naissance. prompt_date = & "Entrer une date de naissance dun musicien" rewind( unit=critere ) case(2) ! Recherche par date de dc`s. e e prompt_date = & "Entrer une date de dc`s dun musicien" e e rewind( unit=critere ) case default ! Quitter exit end select

Corrigs e
253
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
! Lecture dune date. do print *, trim(prompt_date) read(*, *, IOSTAT=ios_stdin) date_saisie if( ios_stdin < 0 ) exit trait if( ios_stdin > 0 ) then print (/,a,/), "Date errone!" e else exit end if end do ! Recherche de la date saisie dans le fichier dindex. trouve = .false. do read( unit=critere, fmt=*, END=1 ) date_lue, numrec if ( date_lue == date_saisie ) then ! On lit lenregistrement correspondant. trouve = .true. read( unit=3, rec=numrec ) mus print *,trim(mus) end if end do 1 if ( .not. trouve ) & print *,"Aucun musicien ne rpond au crit`re indiqu." e e e print (/) end do trait close( unit=1 ); close( unit=2 ); close( unit=3 ) end program sequentiel_indexe

Corrigs e
254
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
program mat_transf implicit none integer, parameter :: n = 10, m = 3 real, dimension(n,m) :: mat integer :: choix_methode, ios, num_ligne real, external :: carre, identite, logarithme real, intrinsic :: sqrt namelist/methode/choix_methode ! Ouverture du fichier contenant la matrice. open( unit=1, file="exo6.matrice", & form="unformatted", action="read", & status="old", position="rewind", & iostat=ios ) if (ios /= 0) & stop Erreur a louverture du fichier "exo6.matrice" ` ! Lecture de la matrice. read(1) mat close(1) ! Ouverture du fichier contenant ! la namelist "methode". open( unit=1, file="exo10.namelist", & form="formatted", action="read", & status="old", position="rewind", & iostat=ios ) if (ios /= 0) & stop Erreur a louverture du fichier "exo10.namelist" ` read( unit=1, nml=methode ) close( unit=1 )

Corrigs e
255
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
! Transformation de la matrice a laide ` ! de la mthode choisie. e select case( choix_methode ) case (1) call transform( mat, n, m, case (2) call transform( mat, n, m, case (3) call transform( mat, n, m, case (4) call transform( mat, n, m, end select
identite ) carre ) sqrt ) logarithme )
! Sauvegarde de la matrice transforme dans e ! le fichier "exo6_matrice_transf". open( unit=1, file="exo6_matrice_transf", & form="formatted", action="write", & status="replace", iostat=ios ) if ( ios /= 0 ) & stop "Erreur lors de louverture & &du fichier ""exo6_matrice_transf""" do num_ligne=1,n write( unit=1, fmt=(3f10.6) ) mat(num_ligne,:) end do close( unit=1 ) end program mat_transf

Corrigs e
256
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
! Procdure de transformation. e subroutine transform( t, n, m, f ) implicit none integer :: n, m, i, j real, dimension(n,m) :: t real :: f do i=1,n do j=1,m t(i,j) = f(t(i,j)) end do end do end subroutine transform ! Dfinitions des fonctions de transformation. e function identite(x) implicit none real x, identite identite = x end function identite function carre(x) implicit none real x, carre carre = x*x end function carre function logarithme(x) implicit none real x, logarithme logarithme = log(x) end function logarithme

Corrigs e Corrig de lexercice 11 e
257
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
program tri_matrice implicit none integer, parameter :: n=10, m=3 real, dimension(n,m) :: mat integer :: ios integer :: i, j ! Lecture de la matrice a trier. ` open( unit=1, & file="exo6.matrice", & form="unformatted", & status="old", & action="read", & position="rewind", & iostat=ios ) if ( ios /= 0 ) stop "Erreur a louverture du fichier & ` &""exo6.matrice""" read( unit=1 ) mat; close( unit=1 ) call tri( mat, n, m ) ! Tri de la matrice lue. ! criture de la matrice trie. E e open( unit=1, file="exo11.matrice_triee", & form="formatted", status="replace", & action="write", position="rewind", & iostat=ios ) if ( ios /= 0 ) stop "Erreur a louverture du fichier & ` &""exo11.matrice_triee""" do i=1,n write( unit=1, fmt=(3F7.3) ) mat(i,:) end do close( unit=1 ) end program tri_matrice

Corrigs e
258
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
! Procdure de tri. e subroutine tri( mat, n, m ) implicit none integer :: n, m real, dimension(n,m) :: mat integer :: ligne, col do ligne=1,n ! Tri des lignes. call tri_vecteur( mat(ligne,:), m ) end do do col=1,m ! Tri des colonnes. call tri_vecteur( mat(:,col), n ) end do contains ! Procdure de tri dun vecteur. e subroutine tri_vecteur( v, n ) integer :: n, i real, dimension(n) :: v logical :: tri_termine do tri_termine = .true. do i=2,n if ( v(i) > v(i-1) ) then tri_termine = .false. ! Utilisation de sections rguli`res pour e e ! effectuer linterversion. v(i-1:i) = v(i:i-1:-1) end if end do if (tri_termine) exit end do end subroutine tri_vecteur end subroutine tri

Index Symboles
* . . . . . . . . . . . . . . . . . . . . . . . 53, 54, 64 ** . . . . . . . . . . . . . . . . . . 53, 54, 57, 64 *.o . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 + . . . . . . . . . . . . . . . . . . 53, 54, 57, 64 - . . . . . . . . . . . . . . . . . . . . . . . 53, 54, 64 -L . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 -c . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 -l . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 -o nom excutable dsir . . . . . 232 e e e .AND. . . . . . . . . . . . . . . . . . . . . . 59, 60 .EQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .EQV. . . . . . . . . . . . . . . . . . . 59, 60, 64 .GE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .GT. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .LE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .LT. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .NE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 .NEQV . . . . . . . . . . . . . . . . . . . . . . . . 64 .NEQV. . . . . . . . . . . . . . . . . . . . . 59, 60 .NOT. . . . . . . . . . . . . . . . . . . . . . 59, 64 .NOT.l . . . . . . . . . . . . . . . . . . . . . . . . 60 .OR. . . . . . . . . . . . . . . . . . . . 59, 60, 64 .f . . . . . . . . . . . . . . . . . . . . . . . . 231, 232 .f90 . . . . . . . . . . . . . . . . . . . . . . 231, 232 .o . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 / . . . . . . . . . . . . . . . . . . . . . . . 53, 54, 64 // . . . . . . . . . . . . . . . . . . . . . . . . . 61, 64 /= . . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 < . . . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 <= . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 = . . . . . . . . . . . . . . . . . . 47, 48, 62, 85 == . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 > . . . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 >= . . . . . . . . . . . . . . . . . . . . . . . . 58, 64 e Elments syntaxiques . . . . . . . . . . 30 Enoncs . . . . . . . . . . . . . . . . . . . . . . 235 e CHARACTER(LEN=*) . . . . . . . . . . . . . . . . 229 GO TO calcul . . . . . . . . . . . . . . . . . . 229 e RETURN multiples . . . . . . . . . . . . . . . 228 ACHAR . . . . . . . . . . . . . . . . . 169, 215 ACOS . . . . . . . . . . . . . . . . . . . . . . . . 215 ACTION : INQUIRE . . . . . . . . . 206 ACTION : OPEN . . . . . . . . . . . . . 199 ADJUSTL . . . . . . . . . . . . . . . . . . . . 215 ADJUSTR . . . . . . . . . . . . . . . . . . . . 215 ADVANCE : READ . . . . . . . . . . 202 ADVANCE : WRITE . . . . . . . . . 204 AIMAG . . . . . . . . . . . . . . . . . . . . . . 216 AINT . . . . . . . . . . . . . . . . . . . . . . . . 216 ANINT . . . . . . . . . . . . . . . . . . . . . . . 216 ANSI . . . . . . . . . . . . . . . . . . . . . . . . . . 10 ar . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 argument procdure . . . . . 173, 174 e argument tableau . . . . . . . . 170172 arguments dappel . . 163, 165, 166 arguments muets . . . . . . . . . . . . . 163 ASA . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 ASCII - table . . . . . . . . . . . . . . . . . . 26 ASIN . . . . . . . . . . . . . . . . . . . . . . . . . 216 ASSIGN . . . . . . . . . . . . . . . . . 227, 228 assign . . . . . . . . . . . . . . . . . . . . . . . . 227 assumed-size array . . . . . . 171, 172 assumed-size string . . . . . . 168, 169 ATAN . . . . . . . . . . . . . . . . . . . . . . . . 216
BACKSPACE . . . . . . . . . . . . . . . . 152 BACSPACE . . . . . . . . . . . . . . . . . . 150 Bases de numration . . . . . . . . . . . 18 e bibliographie . . . . . . . . . . . . . . . . . . 14 biblioth`que . . . . . . . . . . . . . . . . . . 233 e BIT SIZE . . . . . . . . . . . . . . . . . . . . 216 BLANK : INQUIRE . . . . . . . . . . 206 BLANK : OPEN . . . . . . . . . . . . . . 200 bloc . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 BLOCK DATA . . . . . . . . . . 185, 186 BTEST . . . . . . . . . . . . . . . . . . . . . . . 217 buffer . . . . . . . . . . . . . . . . . . . . . . . . . 94
.AND. . . . . . . . . . . . . . . . . . . . . . . . . . 64
ABS . . . . . . . . . . . . . . . . . . . . . . . . . . 215 acc`s direct . . . . . . . . . . . . . . 136139 e ACCESS . . . . . . . . . . . . . . . . 136, 137 ACCESS : INQUIRE . . . . . . . . . 206 ACCESS : OPEN . . . . . . . . . . . . . 198
CALL . . . . . . . . . . . . . . . . . . . . . . . . 165 CASE . . . . . . . . . . . . . . . . . . . . . . . . . 69 CASE DEFAULT . . . . . . . . . . . . . . 69 CEILING . . . . . . . . . . . . . . . . . . . . . 217 CHARACTER . 36, 38, 49, 61, 62, 69 CHARACTER* . . . . . . . . . . . . . . . 229 CLOSE . . . . . . . . . . . . . . . . . . . 95, 213 CLOSE : IOSTAT . . . . . . . . . . . . 212
258-1
CLOSE : STATUS . . . . . . . . . . . . 212 CLOSE : UNIT . . . . . . . . . . . . . . . 212 CMPLX . . . . . . . . . . . . . . . . . . . . . . 217 commentaires . . . . . . . . . . . . . . . . . . 31 COMMON 182, 183, 185, 186, 188, 190192 COMMON blanc . . . . . . . . . . . . . 182 compatibilit . . . . . . . . . . . . . . . . . . 11 e compilateur . . . . . . . . . . . . . . . . . . 231 COMPLEX . . . . . . . . . . . . 36, 43, 56 CONJG . . . . . . . . . . . . . . . . . . . . . . 217 Constantes cha nes de caract`res e 44 Constantes complexes . . . . . . . . . 43 Constantes enti`res . . . . . . . . . . . . 40 e Constantes littrales . . . . . . . . . . . 40 e Constantes relles e : double prcision . . . . . . . . . 42 e Constantes relles e : simple prcision . . . . . . . . . 41 e Constantes symboliques . . . . . . . 48 CONTAINS . . . . . . . . . . . . . . 175177 Corrigs . . . . . . . . . . . . . . . . . . . . . . 240 e COS . . . . . . . . . . . . . . . . . . . . . . . . . . 217 COSH . . . . . . . . . . . . . . . . . . . . . . . . 217 CYCLE . . . . . . . . . . . . . . . . . . . . . . . .78
Diffrents types . . . . . . . . . . . . . . . 35 e DIMENSION . . . . . . . . . . . 36, 80, 81 direct . . . . . . . . . . . . . . . . . . . . . . . . . 95 DIRECT : INQUIRE . . . . . . . . . 207 DO . . . . . . . . . . . . . . . . . . . . 76, 86, 88 documentation . . . . . . . . . . . . . 15, 16 DOUBLE PRECISION . 36, 56, 57 Dure de vie des identificateurs 178 e
Dclaration . . . . . . . . . . . . . . . . . . . . 80 e Dclarations . . . . . . . . 3739, 48, 49 e Dfinitions (rang, profil, tendue) e e 82 DATA . . . . . . . . . . . . . . . . 45, 88, 229 DBLE . . . . . . . . . . . . . . . . . . . . . . . . 218 DELIM . . . . . . . . . . . . . . . . . . . . . . . 134 DELIM : INQUIRE . . . . . . . . . . . 207 DELIM : OPEN . . . . . . . . . . . . . . 200 descripteur / . . . . . . . . . . . . . . . . . 125 descripteur de format . . . . . . . . 110 descripteur de format : Litteral string . . . . . . . . . . . 122 descripteur de format A .108, 109, 120, 121 descripteur de format E . 106, 115 descripteur de format E, D . . . 114 descripteur de format EN . . . . . 116 descripteur de format ES . . . . . 117 descripteur de format F . 105, 112 descripteur de format I . . 104, 111 descripteur de format L . 107, 119 descripteurs . . . . . . . . . . . . . . . . . . 100 descripteurs de contrle . 123, 124 o descripteurs de format . . . . . . . . 103 descripteurs de format SS,SP,S 118 destruction fichier . . . . . . . . . . . . 146
ELSE . . . . . . . . . . . . . . . . . . . . . . . . . . 67 END . . . . . . . . . . . . . . . . . . . . . . . . . . 67 END : READ . . . . . . . . . . . . . . . . . 202 END BLOCK DATA . . . . . . . . . . 186 END SELECT . . . . . . . . . . . . . . . . . 69 ENDFILE . . . . . . . . . . . . . . . 150, 152 enregistrement logique . . . . . . . . . 94 entre standard . . . . . . . . . . . . . . 156 e EOR : READ . . . . . . . . . . . . . . . . . 202 EQUIVALENCE . . . . . . . . . . 49, 191 ERR : INQUIRE . . . . . . . . . . . . . 207 ERR : READ . . . . . . . . . . . . . . . . . 202 ERR : WRITE . . . . . . . . . . . . . . . 204 Exercices . . . . . . . . . . . . . . . . 235, 240 EXIST : INQUIRE . . . . . . . . . . . 207 EXIT . . . . . . . . . . . . . . . . . . . . . . . . . . 76 EXP . . . . . . . . . . . . . . . . . . . . . . . . . 218 EXTERNAL . . . . . . . . . . . . . . 36, 173
f90 . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 facteur de rptition . . . . . . . . . . 126 e e fichier : positionnement . . 150152 fichier binaire . . . . . . . . . . . . . . . . 137 fichier binaire squentiel . . . 97, 98 e fichier destruction . . . . . . . . . . . . 146 fichier interne . . . . . . . . . . . . 147149 fichier temporaire . . . . . . . . . . . . 145 fichier texte . . . . . . . . . . . . . . . . . . 139 fichier texte squentiel . . . . 99, 102 e FILE : INQUIRE . . . . . . . . . . . . . 207 FILE : OPEN . . . . . . . . . . . . . . . . 197 FLOOR . . . . . . . . . . . . . . . . . . . . . . 218 FMT . . . . . . . . . . . . . . . . . . . . . . . . . . 99 FMT : READ . . . . . . . . . . . . . . . . 201 FMT : WRITE . . . . . . . . . . . . . . . 203 fonction . . . . . . . . . . . . . . . . . . . . . . 166 fonction : statement function . 229 FORM : INQUIRE . . . . . . . . . . . 208 FORM : OPEN . . . . . . . . . . . . . . . 199 format : facteur de rptition . 126 e e FORMAT : instruction . . . . . . . 157 format : rexploration . . . 127129 e format ddition . . . . . . . . . . . . . . 100 e
258-2
format fixe . . . . . . . . . . . . . . . 31, 229 format libre . . . . . . . . . 130132, 229 FORMAT(9H A viter) . . . . . . . 228 e FORMATTED : INQUIRE . . . . 208 Fortran 95 . . . . . . . . . . . 14, 227229 Fortran Market . . . . . . . . . . . . . . . . 16 FUNCTION . . . . . . . . . . . . . 166, 167
. . .G. . . 20, 2830 18, Gnralits . e e e ..

GO TO . . . . . . . . . . . . . . . . . . . . . . . 227 GO TO calcul . . . . . . . . . . . . . . . 229 e GOTO . . . . . . . . . . . . . . . . . . . . . . . . 71
IACHAR . . . . . . . . . . . . . . . . . . . . . 218 IAND . . . . . . . . . . . . . . . . . . . . . . . . 218 IBCLR . . . . . . . . . . . . . . . . . . . . . . . 218 IBITS . . . . . . . . . . . . . . . . . . . . . . . . 219 IBM/SP6 . . . . . . . . . . . . . . . . . . . . . . 15 IBSET . . . . . . . . . . . . . . . . . . . . . . . 219 ICHAR . . . . . . . . . . . . . . . . . . . . . . . 169 Identificateurs . . . . . . . . . . . . . . . . . 34 IEOR . . . . . . . . . . . . . . . . . . . . . . . . 219 IF . . . . . . . . . . . . . . . . . . . . . 67, 76, 78 IF arithmtique . . . . . . . . . . . . . . 227 e IMPLICIT NONE . . . . . . . . . . . . . 39 INCLUDE . . . . . . . . . . . . . . . 192, 194 INDEX . . . . . . . . . . . . . . . . . . . . . . . 219 Initialisation . . . . . . . . . . . . . . . 45, 85 INQUIRE . . . . . . . . . . . 153, 154, 205 INQUIRE : ACCESS . . . . . . . . . 206 INQUIRE : ACTION . . . . . . . . . 206 INQUIRE : BLANK . . . . . . . . . . 206 INQUIRE : DELIM . . . . . . . . . . . 207 INQUIRE : DIRECT . . . . . . . . . 207 INQUIRE : ERR . . . . . . . . . . . . . 207 INQUIRE : EXIST . . . . . . . . . . . 207 INQUIRE : FILE . . . . . . . . . . . . . 207 INQUIRE : FORM . . . . . . . . . . . 208 INQUIRE : FORMATTED . . . . 208 INQUIRE : IOSTAT . . . . . . . . . . 208 INQUIRE : NAME . . . . . . . . . . . 208 INQUIRE : NAMED . . . . . . . . . . 209 INQUIRE : NEXTREC . . . . . . . 209 INQUIRE : NUMBER . . . . . . . . 209 INQUIRE : OPENED . . . . . . . . . 209 INQUIRE : PAD . . . . . . . . . . . . . 209 INQUIRE : POSITION . . . . . . . 210 INQUIRE : READ . . . . . . . . . . . . 210 INQUIRE : READWRITE . . . . 210 INQUIRE : RECL . . . . . . . . . . . . 210 INQUIRE : SEQENTIAL . . . . . 211 INQUIRE : UNFORMATTED 211
INQUIRE : UNIT . . . . . . . . . . . . 206 INQUIRE : WRITE . . . . . . . . . . 211 INT . . . . . . . . . . . . . . . . . . . . . . . . . . 220 INTEGER . 36, 39, 56, 62, 69, 73, 86 INTRINSIC . . . . . . . . . . . . . . . 36, 173 IOR . . . . . . . . . . . . . . . . . . . . . . . . . . 220 IOSTAT . . . . . . . . . . . . . . . . . . . . . . 137 IOSTAT : CLOSE . . . . . . . . . . . . 212 IOSTAT : INQUIRE . . . . . . . . . . 208 IOSTAT : OPEN . . . . . . . . . . . . . 197 IOSTAT : READ . . . . . . . . . . . . . 202 IOSTAT : WRITE . . . . . . . . . . . . 204 ISHFT . . . . . . . . . . . . . . . . . . . . . . . 220 ISHFTC . . . . . . . . . . . . . . . . . . . . . . 220 ISO . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Jeu de caract`res . . . . . . . . . . . . . . 28 e
. .L. .. . . . 168, 221 LEN . . . . . . . . . . . . .

LEN TRIM . . . . . . . . . . . . . . . . . . . 221 Les itrations . . . . . . . . . . . . . . . . . . 71 e Les tests . . . . . . . . . . . . . . . . . . . . . . 67 LGE . . . . . . . . . . . . . . . . . . . . . . . . . 221 LGT . . . . . . . . . . . . . . . . . . . . . . . . . 221 libxxx.a . . . . . . . . . . . . . . . . . . . . . . 233 LLE . . . . . . . . . . . . . . . . . . . . . . . . . . 222 LLT . . . . . . . . . . . . . . . . . . . . . . . . . . 222 loader . . . . . . . . . . . . . . . . . . . . . . . . 231 LOG . . . . . . . . . . . . . . . . . . . . . . . . . 222 LOG10 . . . . . . . . . . . . . . . . . . . . . . . 222 LOGICAL . . . . . . . . . . 36, 67, 69, 76
make . . . . . . . . . . . . . . . . . . . . . . . . . 232 Manipulation de tableaux . . . . . 89 MAX . . . . . . . . . . . . . . . . . . . . . . . . . 222 MIN . . . . . . . . . . . . . . . . . . . . . . . . . . 223 MOD . . . . . . . . . . . . . . . . . . . . . . . . . 223 module excutable . . . . . . . . . . . . 231 e module objet . . . . . . . . . . . . . . . . . 231
NAME : INQUIRE . . . . . . . . . . . 208 NAMED : INQUIRE . . . . . . . . . . 209 NAMELIST . . . . . . . . . . 99, 133135 NEXTREC : INQUIRE . . . . . . . 209 NML . . . . . . . . . . . . . . . . . . . . . 99, 134 NML : READ . . . . . . . . . . . . . . . . 201 NML : WRITE . . . . . . . . . . . . . . . 203 normalisation . . . . . . . . . . . . . . . . . . 10
258-3
norme . . . . . . . . . . . . . . . . . . . . . . . . . 10 NOT . . . . . . . . . . . . . . . . . . . . . . . . . 223 NUMBER : INQUIRE . . . . . . . . 209
Oprateur daffectation . . . . . . . . 62 e Oprateur de concatnation . . . 61 e e Oprateurs arithmtiques . . . . . . 53 e e Oprateurs et expressions . 53, 58, e 59, 61, 62, 64 Oprateurs logiques . . . . . . . . . . . 59 e Oprateurs relationnels . . . . . . . . 58 e OPEN . . . . . . . . . . . 95, 97, 197, 213 OPEN : ACCESS . . . . . . . . . . . . . 198 OPEN : ACTION . . . . . . . . . . . . . 199 OPEN : BLANK . . . . . . . . . . . . . . 200 OPEN : DELIM . . . . . . . . . . . . . . 200 OPEN : FILE . . . . . . . . . . . . . . . . 197 OPEN : FORM . . . . . . . . . . . . . . . 199 OPEN : IOSTAT . . . . . . . . . . . . . 197 OPEN : PAD . . . . . . . . . . . . . . . . . 200 OPEN : POSITION . . . . . . . . . . 199 OPEN : RECL . . . . . . . . . . . . . . . 199 OPEN : STATUS . . . . . . . . . . . . . 198 OPEN : UNIT . . . . . . . . . . . . . . . . 197 OPENED : INQUIRE . . . . . . . . . 209
READ : REC . . . . . . . . . . . . . . . . . 202 READ : SIZE . . . . . . . . . . . . . . . . 202 READ : UNIT . . . . . . . . . . . . . . . . 201 READWRITE : INQUIRE . . . . 210 REAL . . 36, 39, 41, 56, 57, 62, 223 REC . . . . . . . . . . . . . . . . . . . . . . . . . 137 REC : READ . . . . . . . . . . . . . . . . . 202 REC : WRITE . . . . . . . . . . . . . . . 204 RECL . . . . . . . . . . . . . . . . . . . 136, 137 RECL : INQUIRE . . . . . . . . . . . . 210 RECL : OPEN . . . . . . . . . . . . . . . 199 REPEAT . . . . . . . . . . . . . . . . . . . . . 223 Reprsentation des donnes . . . . 20 e e return . . . . . . . . . . . . . . . . . . . . . . . . 166 REWIND . . . . . . . . . . . . . . . . 150, 151
PAD : INQUIRE . . . . . . . . . . . . . 209 PAD : OPEN . . . . . . . . . . . . . . . . . 200 PARAMETER . . . . . . . . 36, 48, 190 PAUSE . . . . . . . . . . . . . . . . . . . . . . . 228 POSITION . . . . . . . . . . . . . . 136, 137 POSITION : INQUIRE . . . . . . . 210 POSITION : OPEN . . . . . . . . . . 199 positionnement dans un fichier 150152 prprocesseur . . . . . . . . . . . . . . . . .231 e PRINT . . . . . . . . . . . . . . . . . . . . . . . 156 Priorit des oprateurs . . . . . . . . 64 e e procdure interne . . . . . . . . 175177 e procdures intrins`ques . . . . . . . 180 e e
squentiel . . . . . . . . . . . . . . . . . . . . . 95 e SAVE . . . . . . 36, 178, 183, 185, 188 SCAN . . . . . . . . . . . . . . . . . . . . . . . . 223 scratch . . . . . . . . . . . . . . . . . . . . . . . 145 SELECT CASE . . . . . . . . 69, 76, 78 SEQUENTIAL : INQUIRE . . . 211 SIGN . . . . . . . . . . . . . . . . . . . . . . . . . 224 SIN . . . . . . . . . . . . . . . . . . . . . . . . . . 224 SINH . . . . . . . . . . . . . . . . . . . . . . . . . 224 SIZE : READ . . . . . . . . . . . . . . . . 202 sortie standard . . . . . . . . . . . . . . . 156 SQRT . . . . . . . . . . . . . . . . . . . . . . . . 224 Statement functions . . . . . . . . . . 229 STATUS : CLOSE . . . . . . . 146, 212 STATUS : OPEN . . . . . . . . . . . . . 198 STOP . . . . . . . . . . . . . . . . . . . . . . . . . 29 Structures de contrle . . . . . 67, 71 o subroutine . . . . . . . . . . . . . . . . . . . . 165 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . 37
READ READ READ READ READ READ READ READ
: : : : : : : :
ADVANCE . . . . . . . . . . 202 END . . . . . . . . . . . . . . . . . 202 EOR . . . . . . . . . . . . . . . . . 202 ERR . . . . . . . . . . . . . . . . . 202 FMT . . . . . . . . . . . . . . . . 201 INQUIRE . . . . . . . . . . . . 210 IOSTAT . . . . . . . . . . . . . 202 NML . . . . . . . . . . . . . . . . 201
table ASCII . . . . . . . . . . . . . . . . . . . 26 Tableaux . . . . . . . . . . . 80, 82, 85, 89 tampon . . . . . . . . . . . . . . . . . . . . . . . . 94 TAN . . . . . . . . . . . . . . . . . . . . . . . . . 224 TANH . . . . . . . . . . . . . . . . . . . . . . . . 224 THEN . . . . . . . . . . . . . . . . . . . . . . . . . 67 TRIM . . . . . . . . . . . . . . . . . . . . . . . . 224
UNFORMATTED : INQUIRE 211 UNIT : CLOSE . . . . . . . . . . . . . . . 212 UNIT : INQUIRE . . . . . . . . . . . . 206 UNIT : OPEN . . . . . . . . . . . . . . . . 197 UNIT : READ . . . . . . . . . . . . . . . . 201
258-4
UNIT : WRITE . . . . . . . . . . . . . . 203 UNIT=* . . . . . . . . . . . . . . . . . . . . . . 156 Unit de programme . . . . . . . . . . . 29 e unit logique . . . . . . . . . . . . . . . . . . 95 e
V
variable . . . . . . . . . . . . . . . . . . . . . . . 35 VERIFY . . . . . . . . . . . . . . . . . . . . . 225
WHILE . . . . . . . . . . . . . . . . . . . . . . . . 74 WRITE : ADVANCE . . . . . . . . . 204 WRITE : ERR . . . . . . . . . . . . . . . 204 WRITE : FMT . . . . . . . . . . . . . . . 203 WRITE : INQUIRE . . . . . . . . . . 211 WRITE : IOSTAT . . . . . . . . . . . . 204 WRITE : NML . . . . . . . . . . . . . . . 203 WRITE : REC . . . . . . . . . . . . . . . 204 WRITE : UNIT . . . . . . . . . . . . . . 203 WWW . . . . . . . . . . . . . . . . . . . . . . . . . 16
258-5

IDRIS Fortran Cours

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

IDRIS Fortran Cours

Загружено:

Авторское право:

Доступные форматы

COURS FORTRAN

Patrick Corde Anne Fouilloux

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

Liste des transparents

e 2.2.4 Reprsentation des logiques . . . . . .

2.2.5 Reprsentation des caract`res . . . . . e e

2.5.1 Format libre

2.5.2 Commentaires . . . . . . . . . . . . . 3 Dclarations . . . . . . . . . . . . . . . . e 3.1 Identicateurs . . . . . . . . . . . . . .

Cours langage Fortran 11 mars 2010

Liste des transparents

3.5.2 Constantes relles simple prcision . . e e

3.5.4 Constantes complexes . . . . . . . . .

Cours langage Fortran 11 mars 2010

Liste des transparents

4.5.1 syntaxe gnrale . . . . . . . . . . . e e 4.5.2 R`gles de typage . . . . . . . . . . . e

Cours langage Fortran 11 mars 2010

Liste des transparents

7.2.2 Fichier texte squentiel . . . . . . . . e

e 7.3 Acc`s direct . . . . . . . . . . . . . . . 136

7.3.1 Fichier binaire ` acc`s direct . . . . . 137 a e

7.4 Fichier temporaire . . . . . . . . . . . . 145

Cours langage Fortran 11 mars 2010

Liste des transparents

Cours langage Fortran 11 mars 2010

Liste des transparents

13 Annexe C : aspects obsol`tes . . . . . . . . 226 e

15 Annexe E : exercices . . . . . . . . . . . . 234

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

 Documentation gnrale e e Supports de cours Fortran 95 IDRIS :

Manuel Fortran 77 pour dbutants (en anglais) : e

Fortran Market Index :

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

Reprsentation des donnes e e

Reprsentation des donnes e e Reprsentation des entiers e

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

Reprsentation des rels e e

Reprsentation des rels e e

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Reprsentation des rels e e

INSTITUT DU DEVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Cours langage Fortran 11 mars 2010

Documentation gnrale e e Supports de cours Fortran 95 IDRIS :