Support de cours complet du langage Fortran

Participez au vote ☆☆☆☆☆★★★★★


Table des matières I
1 Introduction Historique bibliographie documentation 2 Généralités Bases de numération Représentation des données Représentation des entiers Représentation des réels Représentation des complexes Représentation des logiques Représentation des caractères Jeu de caractères Notion d’unité de programme Éléments syntaxiques Format libre Commentaires 3 Déclarations Identificateurs Différents types Syntaxe Le type CHARACTER Instruction IMPLICIT NONE Constantes littérales Constantes entières
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	2 / 262


Table des matières II
Constantes réelles simple précision Constantes réelles double précision Constantes complexes Constantes chaînes de caractères Initialisation L’instruction DATA Le symbole ” = ” Constantes symboliques Instruction EQUIVALENCE 4 Opérateurs et expressions Opérateurs arithmétiques Les opérateurs Conversion implicite Opérateurs relationnels Opérateurs logiques Les tables de vérité Opérateur de concaténation Opérateur d’affectation syntaxe générale Règles de typage Priorité des Opérateurs 5 Structures de contrôle Les tests Le bloc IF Le bloc SELECT-CASE
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	3 / 262

Table des matières III
Les itérations L’instruction GOTO Les bloucles DO 6 Tableaux Déclaration Définitions (rang, profil, étendue) Initialisation Le symbole "=" Le constructeur de vecteurs L’instruction DATA Manipulation de tableaux Expressions de type tableau Sections de tableaux 7 Entrées-Sorties Introduction Accès séquentiel Fichier binaire séquentiel Fichier texte séquentiel Accès direct Fichier binaire à accès direct Fichier texte à accès direct Fichier temporaire Destruction d’un fichier Fichier interne Instructions de positionnement
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	4 / 262


Table des matières IV
Instruction INQUIRE Formats BOZ Unités standards Instruction FORMAT Mots clés END=, ERR= 8 Procédures Arguments Subroutines Fonctions Arguments de type chaîne de caractères Arguments de type tableau Arguments de type procédure Procédures internes Durée de vie et visibilité des identificateurs Procédures intrinsèques 9 Common L’instruction COMMON Common blanc Common étiqueté Initialisation : BLOCK DATA Instruction SAVE et COMMON Règles et restrictions 10 Include La directive INCLUDE
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013	5 / 262
Introduction
1 Introduction Historique bibliographie documentation 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux 7 Entrées-Sorties 8 Procédures 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	6 / 262

Introduction		Historique
• Code machine (notation numérique en octal); • Assembleurs de codes mnémoniques; • 1954 : projet création du premier langage symbolique FORTRAN par John Backus d’IBM (MathematicalFORmulaTRANslating System) : • Efficacité du code généré (performance) ; • Langage quasi naturel pour scientifiques (productivité, maintenance, lisibilité). • 1957 : Livraison des premiers compilateurs ; • 1958 : Fortran II (IBM) ?sous-programmes compilables de façon indépendante. • Généralisation aux autres constructeurs mais : • divergences des extensions ?nécessité de normalisation; • ASA American Standards Association (ANSI American Nat. Standards Institute). Comité chargé du développement d’une norme Fortran. • 1966 : Fortran IV (Fortran 66) ; • Évolution par extensions divergentes. .. • 1977 : Fortran V (Fortran 77). quasi compatible : aucune itération des boucles nulles (DO I=1,0) • Nouveautés principales : • type caractère ; • IF-THEN-ELSE; • E/S accès direct et OPEN.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 7 / 262
Introduction		Historique
• Travail des comités X3J3/ANSI et WG5/ISO pour moderniser Fortran 77 : • Standardisation : inclusion d’extensions; • Développement : nouveaux concepts déjà exploités par langages plus récents APL, Algol, PASCAL, Ada; • Performances en calcul scientifique; • Totalement compatible avec Fortran 77. • 1991/1992 : Norme Fortran 90 (ISO et ANSI); • 1994 : Premiers compilateurs Fortran 90 Cray et IBM; • 1997 : Norme Fortran 95 (ISO et ANSI); • 1999 : Premiers compilateurs Fortran 95 sur Cray T3E puis IBM RS/6000; • septembre 2004 : Norme Fortran 2003 (ISO et ANSI); • octobre 2010 : Norme Fortran 2008 (ISO et ANSI).
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 8 / 262

Introduction		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, Programmer’s guide to Fortran 90, 3^e édit. Unicomp, 1996, (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 spécificités du Fortran 90, Éditions 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; • 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, O’Reilly & Associates Inc., 1994, (389 pages), ISBN 1-56592-049-X;
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 9 / 262
Introduction		bibliographie
• Lignelet P., Fortran 90 : approche par la pratique, Éditions Studio Image (série informatique), 1993, ISBN 2-909615-01-4; • Lignelet P., Manuel complet du langage Fortran 90 et Fortran 95, calcul intensif et génie logiciel, Col. Mesures physiques,Masson, 1996, (320 pages), ISBN 2-225-85229-4; • Lignelet P., Structures de données et leurs 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; • Metcalf M., Reid J., • Fortran 90 explained, Science Publications, Oxford, 1994, (294 pages), ISBN 0-19-853772-7, Traduction française par Pichon B. et Caillat M., Fortran 90 : les concepts fondamentaux, Éditions 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 données numériques avec Fortran 90, Masson, 1996, (364 pages), ISBN 2-225-85259-6;
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 10 / 262

Introduction		bibliographie
• 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 l’AFNOR.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 11 / 262
Introduction		documentation
• Documentation IBM/SP6 : • XL Fortran Language Reference • XL Fortran USER’s Guide • ESSL - Engineering and Scientific Subroutine Library Guide • Disponibles sur le serveur Web IDRIS à l’adresse : • Documentation IDRIS IBM/SP6 : • descriptif matériel et logiciel, • supports de cours, • FAQ, • Disponibles sur le serveur Web IDRIS à l’adresse : • Documentation générale • Supports de cours Fortran 95 IDRIS : • Manuel "Fortran 77 pour débutants" (en anglais) : • Fortran Market Index : • État d’avancement de l’intégration de la norme Fortran 2003 : • ancement de l’intégration de la norme Fortran 2008 :
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013	12 / 262

Généralités
1 Introduction 2 Généralités Bases de numération Représentation des données Représentation des entiers Représentation des réels Représentation des complexes Représentation des logiques Représentation des caractères Jeu de caractères Notion d’unité de programme Éléments syntaxiques Format libre Commentaires 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	13 / 262
Généralités
7 Entrées-Sorties 8 Procédures 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	14 / 262

Généralités

Bases de numération

Soit un nombre n dont l’écriture en base b est de la forme :

(upup?1 .u1u0)b

avec :

?i ? {0,1, ,p}

0 ? u_i < b

La valeur du nombre n en base 10 est :

n10 = Ppi=0 uibi

Les ordinateurs ne savent calculer qu’en base 2, de ce fait les données stockées dans la mémoire le sont sous la forme d’une suite de chiffres binaires 0 et 1 appelés bits abréviation de binary digits. Un ensemble de 8 bits s’appelle un octet.

L’écriture des données en base 2 se révèle fastidieuse. Par commodité, on adopte plutôt la base 8 (base octale) ou la base 16 (hexadécimale) pour les définir.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 15 / 262

Généralités		Représentation des données
Représentation des réels
Un nombre réel ou flottant est caractérisé par : 1 son signe; 2 son exposant ou caractéristique; 3 sa mantisse. Son mode de représentation est un motif binaire respectant la norme IEEE. Représentation d’un nombre réel sur32bits Ce type de réel, appelé réel simple précision, admet un motif binaire de la forme : seeeeeeeem—–m avec : • s : bit de signe; • e : exposant sur 8 bits à excédent 127; • m : mantisse sur 23 bits. Le nombre représenté correspond à ? r = s1.m × 2^e?¹²⁷
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013	18 / 262

Généralités

Représentation des données

Ce type de représentation permet de représenter les nombres :

1.2×10^?³⁸? |r| ?3.4×10⁺³⁸

avec 6 chiffres significatifs.

Représentation d’un nombre réel sur64bits

Ce type de réel, appelé réel double précision, admet un motif binaire de la forme :

seeeeeeeeeeem—–m

avec :

• s : bit de signe,

• e : exposant sur 11 bits à excédent 1023,

• m : mantisse sur 52 bits.

Le nombre représenté correspond à ? r = s1.m × 2^e?¹⁰²³ Ce type de représentation permet de représenter les nombres :

2.2×10^?³⁰⁸? |r| ?1.8×10⁺³⁰⁸

avec 15 chiffres significatifs.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

19 / 262

Généralités

Représentation des données

Représentation du réel 10,4 sur 32 bits

On peut écrire ce réel sous la forme suivante :

10,4 =

110100

= 1012 2

L’écriture en binaire du nombre réel 10,4 est finalement :

10,410= 1010,01100110011001100110 2 = 1,01001100110011001100110 ×2³

= 1,01001100110011001100110 ×2^130-127

On en déduit alors le motif binaire suivant :

01000001001001100110011001100110 = 41266666₁₆

| {z }| {z }

exposant 130 mantisse (23bits)

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 20 / 262

Généralités

Représentation des données

Représentation du réel 10,4 sur 64 bits

Pour le codage de ce réel sur 64 bits il suffit de prolonger son écriture binaire d’autant. On obtient :

10,410 =1010,0110011001100110011001100110011001100110011001100

=1,0100110011001100110011001100110011001100110011001100 ×2³

=1,0100110011001100110011001100110011001100110011001100 ×2^1026-1023

On en déduit alors sa représentation interne :

10,4I 0100000000100100110011001100110011001100110011001100110011001100

| {z }| {z } exposant 1026 mantisse (52bits)

I 4024CCCCCCCCCCCC₁₆

Remarque :

• En vérité, le motif en mémoire est 4024CCCCCCCCCCCD car lors de la troncature le 1^er bit perdu à pour valeur 1.

• Sur 32 bits ce n’était pas le cas car le bit perdu à pour valeur 0.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 21 / 262

Généralités		Représentation des données
Représentation des logiques
Un logique est une entité qui peut prendre comme valeur : • .TRUE. • .FALSE. Il est représenté en général sur 32 bits (4 octets). Il peut exister des variantes codées sur 1, 2 voire 8 octets. Tous les bits sont positionnés à 0 sauf le bit le plus à droite qui pour la valeur .TRUE. est positionné à 1.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 23 / 262
Généralités		Représentation des données
Représentation des caractères
Un caractère est codé sur 1 octet. Sa représentation interne respecte un codage appelé codage ASCII. Il existe 128 caractères différents dont les représentations sont indiquées dans une table dite table ASCII. Dans cette table les caractères numériques ainsi que les caractères alphabétiques (majuscules et minuscules) sont rangés consécutivement et en ordre croissant. On appelle chaîne de caractères une suite de caractères rangés de façon consécutive en mémoire.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 24 / 262

Généralités

Représentation des données

Table 1:table des codes ASCII des caractères

Caract.	déc.	hex	oct.	Caract.	déc.	hex	oct.
C-@ (NUL)		0x00	000	espace	32	0x20	040
C-a (SOH)	1	0x01	001	!	33	0x21	041
C-b (STX)	2	0x02	002	"	34	0x22	042
C-c (ETX)	3	0x03	003	#	35	0x23	043
C-d (EOT)	4	0x04	004	$	36	0x24	044
C-e (ENQ)	5	0x05	005	%	37	0x25	045
C-f (ACK)	6	0x06	006	&	38	0x26	046
C-g (BEL)	7	0x07	007	’	39	0x27	047
C-h (BS)	8	0x08	010	(	40	0x28	050
C-i (HT)	9	0x09	011	)	41	0x29	051
C-j (LF)	10	0x0a	012	*	42	0x2a	052
C-k (VT)	11	0x0b	013	+	43	0x2b	053
C-l (FF)	12	0x0c	014	,	44	0x2c	054
C-m (CR)	13	0x0d	015	-	45	0x2d	055
C-n (SO)	14	0x0e	016	.	46	0x2e	056
C-o (SI)	15	0x0f	017	/	47	0x2f	057
C-p (DLE)	16	0x10	020		48	0x30	060
C-q (DC1)	17	0x11	021	1	49	0x31	061
C-r (DC2)	18	0x12	022	2	50	0x32	062
C-s (DC3)	19	0x13	023	3	51	0x33	063
C-t (DC4)	20	0x14	024	4	52	0x34	064
C-u (NAK)	21	0x15	025	5	53	0x35	065
C-v (SYN)	22	0x16	026	6	54	0x36	066
C-w (ETB)	23	0x17	027	7	55	0x37	067
C-x (CAN)	24	0x18	030	8	56	0x38	070
C-y (EM)	25	0x19	031	9	57	0x39	071
C-z (SUB)	26	0x1a	032	:	58	0x3a	072
C-[ (ESC)	27	0x1b	033	;	59	0x3b	073
C-\ (FS)	28	0x1c	034	<	60	0x3c	074
C-] (GS)	29	0x1d	035	=	61	0x3d	075
C-$ (RS)	30	0x1e	036	>	62	0x3e	076
C-_ (US)	31	0x1f	037	?	63	0x3f	077

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

25 / 262

Généralités

Représentation des données

Table 2:table des codes ASCII des caractères (suite)

Caract.	déc.	hex	oct.	Caract.	déc.	hex	oct.
@	64	0x40	100	‘	96	0x60	140
A	65	0x41	101	a	97	0x61	141
B	66	0x42	102	b	98	0x62	142
C	67	0x43	103	c	99	0x63	143
D	68	0x44	104	d	100	0x64	144
E	69	0x45	105	e	101	0x65	145
F	70	0x46	106	f	102	0x66	146
G	71	0x47	107	g	103	0x67	147
H	72	0x48	110	h	104	0x68	150
I	73	0x49	111	i	105	0x69	151
J	74	0x4a	112	j	106	0x6a	152
K	75	0x4b	113	k	107	0x6b	153
L	76	0x4c	114	l	108	0x6c	154
M	77	0x4d	115	m	109	0x6d	155
N	78	0x4e	116	n	110	0x6e	156
O	79	0x4f	117	o	111	0x6f	157
P	80	0x50	120	p	112	0x70	160
Q	81	0x51	121	q	113	0x71	161
R	82	0x52	122	r	114	0x72	162
S	83	0x53	123	s	115	0x73	163
T	84	0x54	124	t	116	0x74	164
U	85	0x55	125	u	117	0x75	165
V	86	0x56	126	v	118	0x76	166
W	87	0x57	127	w	119	0x77	167
X	88	0x58	130	x	120	0x78	170
Y	89	0x59	131	y	121	0x79	171
Z	90	0x5a	132	z	122	0x7a	172
[	91	0x5b	133	{	123	0x7b	173
\	92	0x5c	134	\|	124	0x7c	174
]	93	0x5d	135	}	125	0x7d	175
ˆ	94	0x5e	136	?	126	0x7e	176
_	95	0x5f	137	C-?	127	0x7f	177

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

26 / 262

Généralités

Jeu de caractères

• 26 lettres de l’alphabet;

• chiffres 0 à 9;

• caractères spéciaux :

!	*	+	"	<
(	=	>	)	;
%	/	-	:	,
?	’	.	&	$

• le caractère espace;

• le caractère _ (underscore).

Remarque :

les caractères minuscules sont convertis en majuscules par le compilateur

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

27 / 262

Généralités

Notion d’unité de programme

Un programme source Fortran est composé de parties indépendantes appelées unités de programme (scoping unit).

Chaque partie est compilée de façon indépendante. Chacune admet son propre environnement. Il sera cependant possible que ces parties communiquent entre elles. Les différentes unités de programme sont :

1 le programme principal; 2 les sous-programmes :

• de type subroutine ;

• de type function.

3 les modules;

4 les block data.

Chaque unité comprend une partie déclarative (déclaration des variables locales, ) suivie d’une partie comportant des instructions exécutables parmi lesquelles peut apparaître l’instruction STOP qui provoque l’interruption du programme.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 28 / 262

Déclarations
1 Introduction 2 Généralités 3 Déclarations Identificateurs Différents types Syntaxe Le type CHARACTER Instruction IMPLICIT NONE Constantes littérales Constantes entières Constantes réelles simple précision Constantes réelles double précision Constantes complexes Constantes chaînes de caractères Initialisation L’instruction DATA Le symbole ” = ” Constantes symboliques Instruction EQUIVALENCE 4 Opérateurs et expressions 5 Structures de contrôle
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	32 / 262

Déclarations
6 Tableaux 7 Entrées-Sorties 8 Procédures 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	33 / 262

Déclarations		Instruction IMPLICIT NONE
Par défaut, les variables dont l’identificateur commence par les caractères I à N sont de type INTEGER. Toutes les autres sont de type REAL. L’instruction IMPLICIT NONE change cette règle car elle impose à l’utilisateur la déclaration de chaque variable. Cette instruction est vivement recommandée car elle permet la détection d’un certain nombre d’erreurs à la compilation. • IMPLICIT NONE se place avant les déclarations des variables, • L’instruction ne s’applique qu’à l’unité de programme qui la contient.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 39 / 262

Déclarations

Initialisation

Une initialisation pourra s’effectuer au moyen de l’instruction suivante :

DATA liste₁/init₁/[, , liste_i/init_i/, ]

• liste_i fait référence à une liste de variables à initialiser,

• init_i indique les valeurs d’initialisation,

• le type des valeurs d’initialisation doit respecter les règles suivantes :

• pour un objet de type caractère ou logique, la constante d’initialisation doit être de même type,

• pour un objet de type entier, réel ou complexe, la constante d’initialisation peut être de l’un de ces types.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 45 / 262

Déclarations

Instruction EQUIVALENCE

• L’instruction EQUIVALENCE permet à des variables de partager la même zone mémoire au sein d’une unité de programme ;

• il n’y a pas de conversion de type ;

• chaque variable garde les propriétés de son type;

• le type CHARACTER ne peut pas être associé à d’autres types.

Syntaxe générale :

EQUIVALENCE(v₁, v₂)[, , (v_i?₁, v_i), ]

où les v_i sont des scalaires (variables simples ou éléments de tableaux).

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

49 / 262

Opérateurs et expressions
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions Opérateurs arithmétiques Les opérateurs Conversion implicite Opérateurs relationnels Opérateurs logiques Les tables de vérité Opérateur de concaténation Opérateur d’affectation syntaxe générale Règles de typage Priorité des Opérateurs 5 Structures de contrôle 6 Tableaux
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	52 / 262

Opérateurs et expressions

7 Entrées-Sorties

8 Procédures

9 Common

10 Include

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fo)

rtran(F95-1)

18 février 2013

53 / 262

Opérateurs et expressions

Opérateurs arithmétiques

Les opérateurs

Table 3:Opérateurs arithmétiques

Symbole	Expression	Interprétation
+	o1 + o2	ajoute o₂ à o₁
+	+ o₁	égal à o₁
-	o1 - o2	soustrait o₂ à o₁
-	- o₁	inverse le signe de o₁
*	o1 * o2	multiplie o₁ par o₂
/	o1 / o2	o₁ divisé par o₂
**	o₁**o₂	élève o₁ à la puissance o₂

Les opérandes o₁ et o₂ peuvent être :

• une constante numérique;

• une variable numérique, précédée ou non d’un opérateur unaire (+ ou -) ;

• une expression arithmétique entre parenthèses.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

54 / 262

Opérateurs et expressions

Opérateurs arithmétiques

Le type d’une expression arithmétique dépend des types de ses opérandes. Dans le cas d’opérateurs binaires :

1 si les 2 opérandes sont du même type alors l’expression arithmétique résultante sera de ce type.

2 si les deux opérandes ne sont pas du même type alors l’expression arithmétique sera évaluée dans le type le plus fort relativement à la hiérarchie suivante :

INTEGER < REAL < DOUBLE PRECISION < COMPLEX

Expression Valeur Type du résultat

99/100 0 INTEGER

7/3 2 INTEGER

(100*9)/5 180 INTEGER

(9/5)*100 100 INTEGER

99./100 0.99 REAL

99./100d0 0.99d0 DOUBLE PRECISION

(1.,2.)+1 (2.,2.) COMPLEX

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 56 / 262

Opérateurs et expressions

Opérateurs logiques

Les opérandes des opérateurs logiques doivent être des expressions de type LOGICAL.

Table 5:Opérateurs logiques

Opérateur	Opération
.NOT.	négation logique
.AND.	conjonction logique
.OR.	disjonction inclusive
.EQV.	équivalence logique
.NEQV.	non-équivalence logique

Table 6:Opérateur de négation

l	.NOT.l
.true.	.false.
.false.	.true.

Table 7:Autres opérateurs

l1	l2	l₁.AND.l₂	l₁.OR.l₂	l₁.EQV.l₂	l₁.NEQV.l₂
.true.	.true.	.true.	.true.	.true.	.false.
.true.	.false.	.false.	.true.	.false.	.true.
.false.	.true.	.false.	.true.	.false.	.true.
.false.	.false.	.false.	.false.	.true.	.false.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013

59 / 262

Opérateurs et expressions

Opérateur d’affectation

variable = expression

où expression est une expression arithmétique, logique ou relationnelle.

• une valeur de type CHARACTER ne peut pas être affectée à une variable numérique ou vice-versa,

• une valeur de type INTEGER peut être affectée à une variable de type REAL,

• une valeur de type REAL peut également être affectée à une variable de type INTEGER. Mais dans ce cas, la valeur est alors tronquée en supprimant la partie fractionnaire.

En supposant dans les expressions suivantes, les variables x de type REAL et n, m de type INTEGER :

Expression Interprétation

x = 5 x = 5.0

n = 0.9999 n = 0 m = -1.9999 m = -1

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 61 / 262

Opérateurs et expressions

Priorité des Opérateurs

Table 8:Ordre de priorité des opérateurs

Opérateur	Associativité
**	D ? G
* et /	G ? D
+ et -	G ? D
//	G ? D
<, <=, ==	G ? D
/=, >, >=
.NOT.	///////
.AND.	G ? D
.OR.	G ? D
.EQV. et .NEQV.	G ? D

En supposant dans les expressions suivantes, les variables a, b, c, d de type REEL et e, f, g de type LOGICAL :

Expression Interprétation

2**3**2 2**(3**2) = 512

5.+4.*9.**2 5.+(4.*(9.**2)) = 329.

.g e.OR.(f.AND.g)

a**.e (((a**b)+c).GT.d).AND.e

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 62 / 262

Structures de contrôle
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle Les tests Le bloc IF Le bloc SELECT-CASE Les itérations L’instruction GOTO Les bloucles DO 6 Tableaux 7 Entrées-Sorties 8 Procédures 9 Common
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	63 / 262
Structures de contrôle
10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	64 / 262

Structures de contrôle

Les itérations

2^re forme : DO WHILE

contrôle_de_boucle est de la forme :

WHILE(expression)

avec expression de type scalaire logique.

Le corps de la boucle est exécuté tant que l’expression est vraie.

Remarque : pour pouvoir sortir de la boucle, il faut que expression puisse prendre la valeur .FALSE. dans le bloc.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 72 / 262

Tableaux
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux Déclaration Définitions (rang, profil, étendue) Initialisation Le symbole "=" Le constructeur de vecteurs L’instruction DATA Manipulation de tableaux Expressions de type tableau Sections de tableaux 7 Entrées-Sorties
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	77 / 262
Tableaux
8 Procédures 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	78 / 262

Tableaux

Déclaration

Un tableau est un ensemble d’éléments de même type contigus en mémoire. Pour déclarer un tableau, il est recommandé d’utiliser l’attribut DIMENSION :

TYPE, DIMENSION(expr₁, ,expr_n) :: liste_tab

avec :

• n ? 7 i.e un tableau peut avoir jusqu’à 7 dimensions;

• expr_i sert à indiquer l’étendue dans la dimension correspondante. C’est une expression entière ou bien deux expressions entières de la forme expr₁:expr₂ avec expr₁ <= expr₂.

• liste_tab est une liste de tableaux.

Remarques :

1 si la déclaration est faite au sein du programme principal ces expressions doivent être construites à l’aide de constantes entières (littérales ou symboliques) ;

2 si celle-ci est effectuée à l’intérieur d’une procédure celles-ci peuvent être variables.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 79 / 262

Tableaux		Définitions (rang, profil, étendue)
• Le rang (rank) d’un tableau est son nombre de dimensions. • Le nombre d’éléments dans une dimension s’appelle l’étendue (extent) du tableau dans cette dimension. • Le profil (shape) d’un tableau est un vecteur dont chaque élément est l’étendue du tableau dans la dimension correspondante. • La taille (size) d’un tableau est le produit des éléments du vecteur correspondant à son profil. • Deux tableaux sont dits conformants s’ils ont le même profil.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 81 / 262

Tableaux		Définitions (rang, profil, étendue)
Ordre des éléments
En mémoire la notion de tableau n’existe pas : les éléments sont rangés les uns à la suite des autres. Pour accéder à ces éléments, dans l’ordre mémoire, Fortran fait d’abord varier le premier indice, puis le second et ainsi de suite. Par exemple, les éléments d’un tableau à deux dimensions sont ordonnés comme suit : REAL, DIMENSION(5,3) :: C?C(1,1),C(2,1), ,C(5,1),C(1,2),C(2,2), ,C(5,3)
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 83 / 262

Tableaux

Initialisation

Un constructeur de vecteur est un vecteur de scalaires dont les valeurs sont encadrées par les caractères « (/ » et « /) » :

tableau = (/ expr₁, expr₂, , expr_n /)

• tableau est un tableau de rang1,

• expr_i est :

• un scalaire,

• une boucle DO implicite de la forme

(expr_scalaire, variable = m₁,m₂[,m₃]) avec variable une variable INTEGER correspondant à l’indice de cette boucle et m₁, m₂, m₃ des constantes entières délimitant la boucle (voir boucle DO).

• Le constructeur et le tableau tableau doivent être conformants.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 85 / 262

Tableaux

Manipulation de tableaux

Les sections régulières de tableaux sont obtenus en faisant varier le ou les indices à l’aide d’un triplet de la forme :

[limite₁]:[limite₂][:pas]

• cette notation est équivalente à une pseudo-boucle;

• une section de tableau est aussi un tableau;

• le rang d’une section de tableau est inférieur ou égal à celui du tableau global;

• un tel triplet indique que l’indice correspondant débute avec la valeur limite₁ et se termine à une valeur ? limite₂ ;

• pas est l’incrément de l’indice.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 89 / 262

Tableaux

Manipulation de tableaux

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.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 91 / 262

Entrées-Sorties

1 Introduction 2 Généralités

3 Déclarations

4 Opérateurs et expressions

5 Structures de contrôle

6 Tableaux

7 Entrées-Sorties

Introduction

Accès séquentiel

Fichier binaire séquentiel

Fichier texte séquentiel

Accès direct

Fichier binaire à accès direct

Fichier texte à accès direct Fichier temporaire

Destruction d’un fichier

Fichier interne

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fo)

rtran(F95-1)

18 février 2013

92 / 262

Entrées-Sorties
Instructions de positionnement Instruction INQUIRE Formats BOZ Unités standards Instruction FORMAT Mots clés END=, ERR= 8 Procédures 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	93 / 262
Entrées-Sorties		Introduction
Introduction
On appelle entrée-sortie, un transfert d’informations entre la mémoire de l’ordinateur et l’un de ses périphériques (un disque le plus souvent). Une entrée se traduit par une lecture d’informations du périphérique vers la mémoire, tandis qu’une sortie implique une écriture de la mémoire vers le périphérique. Ces informations sont stockées dans un fichier qui possède un nom. L’unité de transmission entre la mémoire et le périphérique s’appelle le bloc. Il permet d’effectuer le traitement en passant par une zone intermédiaire dite zone tampon (buffer) permettant ainsi de limiter le nombre de transferts entre la mémoire et le périphérique : opération coûteuse. L’unité de traitement est l’enregistrement logique : il correspond à la longueur des données traitées lors d’une opération de lecture-écriture.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 94 / 262

Entrées-Sorties		Introduction
L’exploitation d’un fichier au sein d’un programme nécessite au préalable son ouverture qui, en Fortran, est faite au moyen de l’instruction OPEN. Cette instruction permet notamment : • de connecter le fichier à un numéro d’unité logique : c’est celui-ci que l’on indiquera par la suite pour toute opération de lecture-écriture, • de spécifier le mode désiré : lecture, écriture ou lecture-écriture, • d’indiquer le mode de transfert : avec ou sans conversion en caractères, • d’indiquer le mode d’accès au fichier : séquentiel ou direct. Si l’ouverture du fichier est fructueuse, des lectures-écritures pourront être lancées à l’aide des instructions READ/WRITE par l’intermédiaire du numéro d’unité logique. Une fois le traitement du fichier terminé, on le fermera au moyen de l’instruction CLOSE.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 95 / 262
Entrées-Sorties		Accès séquentiel
Accès séquentiel
On dit qu’un fichier est séquentiel lorsqu’il est nécessaire d’avoir traité les enregistrements précédant celui auquel on désire accéder. Pour un fichier en lecture le paramètre IOSTAT de l’instruction READ permet notamment de gérer la fin de fichier; celui-ci fait référence à une variable entière qui est valorisée à l’issue de la lecture comme suit : • à 0 si la lecture s’est bien déroulée; • à une valeur positive si une erreur s’est produite ; • à une valeur négative si la fin de fichier ou une fin d’enregistrement a été rencontrée. On prendra soin de tester la valeur de cette variable immédiatement après chaque lecture. Pour une analyse plus fine des erreurs de lecture se reporter à la page 159.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 96 / 262

Entrées-Sorties		Accès séquentiel
On demande l’ouverture du fichier dont le nom est data_bin_seq. C’est un fichier binaire séquentiel (unformatted, sequential) que l’on désire lire depuis le début (rewind). Ce fichier est connecté à l’unité logique dont le numéro est 1. C’est ce numéro que l’on indique au moment de la lecture des variables tab, i, r, ainsi qu’à la fermeture du fichier. En cas d’erreur lors de l’ouverture d’un fichier, en l’absence du mot-clé IOSTAT le programme s’interrompt avec édition d’un message résumant l’erreur. Ici ce mot-clé est précisé. Il permet de personnaliser le traitement en cas d’erreur. Il fait référence à une variable entière (ici la variable ios) laquelle, à l’issue de l’OPEN, est valorisée de la façon suivante : • à zéro si tout s’est bien passé, • à une valeur non nulle si une erreur s’est produite. Il faudra évidemment la tester avant d’entreprendre toute opération d’entrée-sortie sur le fichier. Ce même mot-clé est précisé au sein de l’instruction READ. Il référence la même variable ios qui reflètera l’état de la lecture une fois celle-ci effectuée. Elle est utilisée pour notamment gérer la fin de fichier.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 98 / 262

Entrées-Sorties		Accès séquentiel
Fichier texte séquentiel
Dans un fichier texte les données sont stockées sous forme de caractères. De ce fait : • lors d’une lecture, elles sont converties en binaire avant d’être rangées en mémoire, • lors d’une écriture, elles sont converties en caractères avant d’être écrites dans le fichier. Cette opération de conversion est signalée au sein des instructions READ/WRITE : • à l’aide d’une chaîne de caractères appelée format d’édition (paramètre FMT=), • ou bien en utilisant un nom de liste (NAMELIST) regroupant les variables que l’on désire exploiter (paramètre NML=).
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 99 / 262
Entrées-Sorties		Accès séquentiel
Formats d’édition
Pour que la conversion puisse être faite, il est nécessaire de connaître le type de la donnée à convertir. Pour cela le format d’édition contient des descripteurs : • 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.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013	100 / 262

Entrées-Sorties		Accès séquentiel
Dans cet exemple, on demande l’ouverture du fichier dont le nom est data_txt_seq. C’est un fichier texte séquentiel (formatted, sequential) existant (old) que l’on désire écraser (rewind). Comme précédemment, à l’issue de l’OPEN on teste la valeur de retour contenue dans l’entier ios. Si l’ouverture s’est bien passée on lance, à l’aide de l’instruction WRITE, l’écriture en caractères d’un enregistrement comportant un tableau de réels (tab) suivi d’un entier puis d’un réel (i, r). Le format d’édition spécifié sous la forme d’une constante chaîne de caractères (’(10F8.4,I3,F6.3)’) permet de convertir en caractères les variables ci-dessus : • 10F8.4 : écriture des 10 éléments du tableau tab. Chacun a un gabarit de 8 caractères avec 4 chiffres en partie décimale, • I3 : écriture de l’entier i sur 3 caractères, • F6.3 : écriture du réel r sur 6 caractères avec 3 chiffres en partie décimale.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 102 / 262

Entrées-Sorties		Accès séquentiel
Formats d’édition en lecture
• Iw permet la conversion des w caractères suivants dans le type INTEGER, • Fw.d : permet la conversion des w caractères suivants dans le type REAL. Si le point décimal n’est pas présent alors les d derniers caractères désignent la partie fractionnaire, • Ew.d : permet la conversion des w caractères suivants (interprétés comme un nombre réel en notation exponentielle) dans le type REAL, • Lw : permet la conversion des w caractères suivants dans le type LOGICAL, • A[w] : permet de lire des caractères.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 103 / 262

Entrées-Sorties		Accès séquentiel
Format d’édition A en lecture
Ce format à la forme générale : A[w] Ce type de format permet la lecture de caractères. La valeur w indique le nombre de caractères que l’on désire traiter en entrée. • si la valeur de w est plus grande que la longueur l de la chaîne réceptrice, ce sont les l caractères les plus à droite qui seront lus, • si elle est plus petite, w caractères seront lus et stockées dans la chaîne réceptrice qui sera complétée à droite par des blancs, • si elle n’est pas précisée, c’est la longueur spécifiée lors de la déclaration de la chaîne de caractères qui indiquera le nombre de caractères à lire. Si la fin de l’enregistrement est atteinte avant la fin de la lecture, la chaîne est complétée par des blancs.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 108 / 262

Entrées-Sorties		Accès séquentiel
Formats d’édition en écriture
• Iw[.d] permet l’édition d’une variable de type INTEGER sur w caractères. S’il est présent d indique le nombre minimum de chiffres édités : si nécessaire des 0 apparaîtront en tête du nombre, • Fw.d : permet l’édition d’une variable de type REAL sur w caractères comprenant le point décimal suivi de d chiffres pour la partie fractionnaire, • Ew.d : idem format F mais la sortie est faite en notation exponentielle, • Lw : permet l’édition d’une variable de type LOGICAL sur w caractères, • A[w] : permet l’édition d’une variable de type CHARACTER.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 110 / 262

Entrées-Sorties		Accès séquentiel
Format d’édition E et D en écriture
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. Un facteur d’échelle peut précéder ce type de format. Il s’écrit sous la forme kP et permet d’éditer le nombre avec k chiffres avant le point décimal (modifie en conséquence la valeur de l’exposant). Si -d < k ? 0, la partie décimale sera constituée de \|k\| zéros suivis de d-\|k\| chiffres significatifs. Si 0 < k < d+2, le nombre en sortie sera constitué de k chiffres significatifs avant le point décimal et de d-k+1 chiffres significatifs en partie décimale. Toute autre valeur de k est invalide : dans ce cas, la zone en sortie sera remplie par le caractère *. Celui-ci s’applique à tous les formats E qui suivent. Pour retrouver le comportement par défaut il suffit de préciser le facteur 0P.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 114 / 262

Entrées-Sorties		Accès séquentiel
Format d’édition A en écriture
Le format A[w] permet la sortie de chaînes de caractères. La valeur w est facultative. Si elle est précisée, elle indique la largeur de la zone réceptrice. • si la valeur de w est plus grande que la longueur l de la chaîne, en sortie celle-ci apparaîtra précédée de w-l blancs, • si elle est plus petite, seuls les w caractères les plus à gauche de la chaîne seront écrits, • si la valeur w est absente, c’est la longueur de la chaîne spécifiée à la déclaration qui indique la largeur du champ en sortie.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 120 / 262

Entrées-Sorties		Accès séquentiel
Descripteurs de contrôle
• descripteurs de positionnement : • nX : ignore (en entrée), saute (en sortie) les n caractères suivants, • Tc : permet de se positionner au caractère de rang c, • TLn : permet de se positionner au caractère situé n positions à gauche par rapport à la position courante, • TRn : permet de se positionner au caractère situé n positions à droite par rapport à la position courante. • descripteurs de gestion des blancs dans les champs numériques en entrée : • BN (Blank Null) : ignore les blancs, • BZ (Blank Zero) : interprète le caractère blanc comme un 0.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 123 / 262

Entrées-Sorties

Accès séquentiel

La règle de réexploration est la suivante :

• si le format ne contient aucun groupe de descripteurs entre parenthèses, alors il est réexploré depuis son début,

• sinon, la réexploration est faite à partir du groupe de niveau 1 le plus à droite. S’il est précédé d’un facteur de répétition, il est pris en compte.

Le caractère « | » dans les exemples suivant indique l’endroit à partir duquel la réexploration est effectué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)) )"

| ?

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 128 / 262

Entrées-Sorties		Accès séquentiel
Format libre
En Fortran il existe un format implicite appelé format libre (list-directed formatting). Dans l’instruction READ/WRITE, on spécifie alors le caractère * à la place du format. Dans ce contexte, les enregistrements sont interprétés comme une suite de valeurs séparées par des caractères appelés séparateurs. C’est le type des variables auxquelles ces valeurs vont être affectées qui détermine la conversion à effectuer. Les caractères interprétés comme des séparateurs sont : • la virgule (,); • le blanc (espace). Une chaîne de caractères contenant un caractère séparateur doit être délimitée soit par des quotes (’) soit par des guillemets ("). En entrée, plusieurs valeurs identiques peuvent être regroupées à l’aide d’un facteur de répétition sous la forme n*valeur.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 130 / 262

Entrées-Sorties		Accès séquentiel
Une constante complexe est codée comme 2 nombres réels entre parenthèses séparés par une virgule. Les parenthèses ainsi que la virgule peuvent être suivies ou précédées de blancs. Une fin d’enregistrement (newline) a le même effet qu’un blanc. Elle peut apparaître : • au sein d’une chaîne de caractères (délimitée par des quotes (’) ou par des guillemets (")), • entre la partie réelle et la virgule ou entre la virgule et la partie imaginaire d’une constante complexe. Si une chaîne de caractères a été déclarée avec une longueur plus petite que celle de la valeur lue alors seuls les caractères les plus à gauche de la valeur seront stockés dans la chaîne. Sinon, celle-ci est complétée par des blancs. Si dans l’enregistrement en entrée apparaissent deux virgules à la suite (éventuellement avec des blancs entre) alors l’élément correspondant de la liste ne sera pas modifié.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 131 / 262

Entrées-Sorties

Accès séquentiel

namelist

On peut regrouper les variables que l’on désire lire ou écrire au sein d’une liste à laquelle on donne un nom.

Ce regroupement s’effectue au moyen de l’instruction NAMELIST :

NAMELIST/nom_liste/liste_variables

• nom_liste est le nom de la NAMELIST,

• liste_variables est une liste de variables précédemment déclarées.

Au niveau de l’instruction READ/WRITE la namelist remplace le format ainsi que la liste de variables qui, dans ce contexte, devient inutile. l’enregistrement correspondant (lu ou écrit) respecte le format suivant :

&nom_liste liste d’affectations /

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 133 / 262

Entrées-Sorties

Accès séquentiel

La liste d’affectations concerne les variables de la namelist qui peuvent apparaître dans n’importe quel ordre, certaines pouvant être omises. Les différentes affectations sont séparées par des caractères séparateurs (, ou blancs).

Le caractère / indique la fin de la namelist. En entrée, les éventuels caractères qui suivent sont ignorés.

En entrée les chaînes de caractères doivent être délimitées à l’aide du caractère ’ ou ". En sortie celles-ci apparaissent par défaut sans délimiteur. C’est le paramètre DELIM= de l’instruction OPEN qui permet de le définir.

Dans l’instruction READ/WRITE, la namelist est indiquée à l’aide du paramètre NML= (à la place de FMT=).

L’utilisation des namelist est un moyen très commode d’effectuer des entrées-sorties sans avoir à définir de format.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 134 / 262

Entrées-Sorties		Accès direct
Accès direct
À la différence d’un fichier séquentiel, il est possible d’accéder à un enregistrement d’un fichier à accès direct sans avoir traité les précédents. Chaque enregistrement est repéré par un numéro qui est son rang dans le fichier. Leur taille est fixe. Au sein de l’instruction OPEN : • le paramètre RECL= est obligatoire, sa valeur indique la taille des enregistrements (en caractères pour les fichiers textes, dépend du processeur pour les fichiers binaires), • le paramètre POSITION= est invalide, • si le paramètre FORM n’est pas précisé, c’est la valeur unformatted qui est prise en compte. Le rang de l’enregistrement que l’on désire traiter doit être spécifié à l’aide du paramètre REC= de l’instruction READ/WRITE. Un enregistrement ne peut pas être détruit mais par contre il peut être réécrit. Dans ce contexte, les namelist ainsi que le format libre sont interdits.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 136 / 262

Entrées-Sorties		Accès direct
Le fichier dont le nom est data_bin_direct est connecté à l’unité logique numéro 1. C’est un fichier binaire à accès direct (ACCESS="direct" et paramètre FORM absent donc considéré égal à unformatted). Chaque enregistrement fait 400 octets (RECL=400). On accède à l’enregistrement de rang n, valeur préalablement lue dans le fichier texte séquentiel de nom data_txt_seq connecté à l’unité logique numéro 2. Le paramètre IOSTAT de l’instruction READ permet de récupérer l’état de la lecture dans l’entier ios : une valeur non nulle positive signale une erreur du type enregistrement inexistant par exemple.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 138 / 262

Entrées-Sorties		Accès direct
On a adapté l’exemple précédent à un fichier texte à accès direct : le paramètre FORM="formatted" a donc été précisé. La valeur du paramètre RECL correspond à la taille en caractères de chacun des enregistrements qui correspond ici au format indiqué au niveau de l’instruction READ (100*8 = 800). Notes : • il n’est pas permis de lire un fichier texte à accès direct au moyen d’un format libre, • un fichier dans lequel on écrit un seul enregistrement de rang n, contiendra en réalité n enregistrements avec les n-1 premiers ayant un contenu indéterminé. Lors de la lecture d’un tel fichier, se pose le problème de la reconnaissance de la nature de celui-ci. On pourra résoudre ce problème en adjoignant aux données une marque sous la forme d’une variable logique par exemple.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 140 / 262

Entrées-Sorties		Accès direct
Notes : • l’instruction INQUIRE( iolength=size ) permet de récupérer dans l’entier size la taille de la liste de variables fournies qui servira à renseigner, par la suite, le paramètre RECL de l’instruction OPEN. Comme cette valeur est exprimée dans une unité dépendant du compilateur (pour les fichiers binaires en accès direct), cette nouvelle forme de l’instruction INQUIRE ², introduite par la norme Fortran 90, permet de la calculer en s’affranchissant de l’unité; • l’instruction call random_number( matrice ) fait appel à la procédure intrinsèque Fortran 90RANDOM_NUMBER qui valorise le tableau transmis à l’aide de nombres aléatoires générés dans l’intervalle [0.,1.]. ²cette instruction est détaillée plus loin.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 143 / 262

Entrées-Sorties		Fichier interne
Fichier interne
On appelle fichier interne un fichier dont les enregistrements sont en mémoire. Ce type de fichier induit des échanges entre zones de la mémoire et non plus entre un support externe et la mémoire. Ces fichiers sont pré-connectés : il n’y a donc aucune ouverture ni fermeture à effectuer. Dans les instructions READ/WRITE, à la place du numéro d’unité logique on indique une variable de type chaîne de caractères. C’est celle-ci qui fait référence à l’enregistrement en mémoire. Seul l’accès séquentiel formaté est permis dans ce cas. Les namelist sont interdites. Lors d’une écriture il faut s’assurer que la chaîne de caractères réceptrice est de taille suffisante. Lors d’une lecture, la fin de fichier est atteinte lorsqu’on essaie d’accéder aux caractères situés au-delà de la chaîne qui fait référence à l’enregistrement.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 146 / 262

Entrées-Sorties		Instructions de positionnement
Instructions de positionnement
Toute opération de lecture-écriture dans un fichier est effectuée par rapport à la position courante dans ce fichier. À l’ouverture celle-ci peut être précisée à l’aide du paramètre POSITION. Dans un fichier séquentiel toute lecture-écriture d’un enregistrement de rang n implique le positionnement à l’enregistrement de rang n+1. Trois instructions BACKSPACE, REWIND et ENDFILE permettent de modifier la position : • BACKSPACE force la position au début de l’enregistrement précédent, • REWIND force la position au début du fichier, • ENDFILE écrit un enregistrement de type fin de fichier. Il est alors nécessaire d’exécuter ensuite l’une des deux instructions précédentes. Ces instructions admettent en paramètre le numéro de l’unité logique auquel le fichier est connecté.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 150 / 262

Procédures
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux 7 Entrées-Sorties 8 Procédures Arguments Subroutines Fonctions Arguments de type chaîne de caractères Arguments de type tableau Arguments de type procédure Procédures internes Durée de vie et visibilité des identificateurs
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	162 / 262

Procédures
Procédures intrinsèques 9 Common 10 Include
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	163 / 262
Procédures		Arguments
Arguments
Très souvent, dans un programme, on a besoin d’effectuer un même traitement plusieurs fois avec des valeurs différentes. La solution est de définir ce traitement une seule fois à l’aide d’une unité de programme de type procédure (SUBROUTINE ou FUNCTION). Les unités de programmes désirant effectuer ce traitement feront appel à cette procédure en lui transmettant des valeurs via des variables appelées arguments d’appel (actual-arguments). La procédure appelée récupère les valeurs qu’on lui a transmises via des variables appelées arguments muets (dummy-arguments). En Fortran le passage de ces valeurs s’effectue par référence; • les adresses des arguments d’appel sont transmises à la procédure appelée, • dans la procédure appelée, les arguments muets sont des alias des arguments d’appel.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 164 / 262

Procédures		Arguments
Schéma passage arguments
Figure 1:Schéma passage arguments
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013	165 / 262

Procédures		Fonctions
Fonctions
Un autre moyen de transmettre des valeurs à une unité de programme est l’utilisation d’une procédure de type FUNCTION. À la différence d’une SUBROUTINE, une FUNCTION retourne une valeur ; celle-ci est donc typée. De plus, son appel s’effectue en indiquant uniquement son nom suivi entre parenthèses de la liste des arguments d’appels. Au sein de la fonction l’instruction return sert à transmettre à la procédure appelante la valeur à retourner. Celle-ci n’est nécessaire que dans le cas où on désire effectuer ce retour avant la fin de la définition de la fonction. Dans la procédure appelante l’expression correspondant à l’appel de la fonction est remplacée par la valeur retournée.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 167 / 262

Procédures		Arguments de type chaîne de caractères
Arguments de type chaîne de caractères
Lorsqu’une chaîne de caractères est transmise en argument, Fortran passe également sa longueur de façon implicite. Dans la procédure appelée, celle-ci peut être récupérée à l’aide de la fonction intrinsèque LEN. La déclaration de la chaîne de caractères au sein de la procédure appelée est faite en spécifiant le caractère « * » à la place de la longueur. La procédure appelée fait alors référence à une chaîne de caractères à taille implicite (assumed-size string).
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 169 / 262

Procédures

Arguments de type tableau

Arguments de type tableau

Lorsqu’un tableau est passé en argument c’est l’adresse de son premier élément qui est transmise.

La procédure appelée doit posséder les informations lui permettant d’adresser les différents éléments de ce tableau.

De façon générale, supposons que l’on dispose d’un tableau tab à 2 dimensions constitué de n lignes et m colonnes. L’adresse de l’élément tab(i,j) est :

@tab(i,j) = @tab(1,1) + [n×(j-1)+(i-1)]×taille(élément)

Le nombre de colonnes m n’intervient pas dans ce calcul.

Souvent en Fortran, lors de l’appel d’une procédure seule la première dimension d’un tableau à 2 dimensions est transmise.

Dans la procédure appelée celui-ci est déclaré en indiquant le caractère « * » à la place de la deuxième dimension. On fait alors référence à un tableau à taille implicite (assumed-size array).

Dans un tel cas, il faut faire preuve d’une certaine prudence car dans la procédure appelée on ne maîtrise pas l’espace mémoire total occupé par le tableau.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 172 / 262

Procédures		Durée de vie et visibilité des identificateurs
Durée de vie et visibilité des identificateurs
On appelle durée de vie d’un identificateur le temps pendant lequel il existe en mémoire. Il est visible s’il existe en mémoire et est accessible, car il peut exister mais être masqué par un autre de même nom (c.f. procédure interne). • Par défaut, une variable a une durée de vie limitée à celle de l’unité de programme dans laquelle elle a été définie, • l’attribut SAVE permet de prolonger la durée de vie à celle de l’exécutable : on parle alors de variable permanente ou statique, • dans une unité de programme l’instruction SAVE sans spécification de liste de variables indique que toutes les variables de cette unité sont permanentes, • une compilation effectuée en mode static force la présence de l’instruction SAVE dans toutes les unités 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 l’attribut SAVE a été précisé, • celles initialisées à la déclaration (via l’instruction DATA ou à l’aide du signe « = »).
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 179 / 262

Procédures		Procédures intrinsèques
Procédures intrinsèques
Le compilateur Fortran dispose d’une bibliothèque de procédures couvrant différents domaines : mathématique, conversion de type, manipulation de chaînes de caractères, comparaison de chaînes de caractères, .. . Pour une procédure donnée, le nom d’appel diffère suivant le type des arguments transmis. Un nom générique permet de s’affranchir de ces types : c’est la solution fortement conseillée car elle facilite la portabilité. Par exemple un appel à la procédure générique ABS, retournant la valeur absolue de son argument, est transformé par le compilateur en un appel à la procédure : • IABS pour un argument entier, • ABS pour un argument réel simple précision, • DABS pour un argument réel double précision, • CABS pour un argument complexe. Une liste des procédures intrinsèques est fournie en annexe B.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 181 / 262
Common
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux 7 Entrées-Sorties 8 Procédures 9 Common L’instruction COMMON Common blanc Common étiqueté Initialisation : BLOCK DATA Instruction SAVE et COMMON
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	182 / 262

Common

Règles et restrictions

10 Include

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fo)

rtran(F95-1)

18 février 2013

183 / 262

Common

L’instruction COMMON

L’instruction COMMON

L’instruction COMMON permet le regroupement de zones mémoires pouvant être partagées par différentes unités de programme (fonctions, procédures). La syntaxe d’une instruction COMMON est la suivante :

COMMON[/[nom_common]/] liste_variables

Le COMMON est dit étiqueté si nom_common est précisé. S’il n’a pas de nom on l’appelle

COMMON blanc.

Les différentes zones regroupées au sein du bloc COMMON sont adressées via des variables dont les noms sont indiqués dans la partie liste_variables de l’instruction COMMON. Pour qu’une unité de programme ait accès à ces zones, il est nécessaire qu’elle contienne l’instruction COMMON les référençant.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 184 / 262

Common		Common blanc
Common blanc
Lors de la déclaration d’un COMMON blanc nom_common est omis et les deux slashes "/" sont alors optionnels. Ses particularités sont : • un COMMON blanc est permanent (il hérite de l’attribut SAVE), • les variables apparaissant dans un COMMON blanc ne peuvent pas être initialisées lors de leur déclaration. Ce type de bloc est initialement constitué de bits à 0. En conséquence : • les données numériques sont initialisées à 0, • les données logiques sont initialisées à la valeur .FALSE., • les données de type chaîne de caractères représentent des chaînes vides. • un COMMON blanc peut ne pas avoir la même taille d’une unité de programme à une autre, c’est alors la taille maximum qui sera retenue pour l’ensemble du programme.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 185 / 262

Common		Common étiqueté
Initialisation : BLOCK DATA
BLOCK DATA est une unité de programme qui permet d’initialiser des objets déclarés dans des COMMONs étiquetés : 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 déclarations de type (INTEGER, REAL, ), • de déclarations de zones communes (COMMON), • d’initialisations statiques (DATA). Un bloc COMMON ne peut apparaître que dans un seul BLOCK DATA. On peut se définir plusieurs unités BLOCK DATA, chacune regroupant les COMMON qui ont un lien logique entre eux.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 188 / 262

Common

Common étiqueté

Instruction SAVE et COMMON

Les valeurs des variables d’un COMMON étiqueté deviennent indéfinies quand une procédure se termine (retour à l’unité appelante) sauf s’il existe une autre unité de programme active le référençant.

Le cas échéant, on lui appliquera l’instruction SAVE pour conserver son contenu :

SAVE/nom_common/

• Un COMMON qui reçoit l’attribut SAVE dans une fonction ou procédure devra toujours être déclaré avec ce même attribut dans toutes les autres unités de programme,

• Il est inutile de spécifier l’attribut SAVE si le COMMON a été déclaré dans le programme principal.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 190 / 262

Common		Règles et restrictions
Règles et restrictions
• Un COMMON ne peut pas contenir : • les noms de procédures (sous-programmes, fonctions), • les arguments de procédures, • les constantes symboliques (ayant l’attribut PARAMETER). • une même variable ne peut pas apparaître dans deux COMMONs de noms différents, • la taille d’un bloc COMMON étiqueté doit être la même dans chaque unité de programme le référençant, • Fortran 90 permet désormais le mélange de données numériques et caractères au sein d’un bloc COMMON, • d’une unité de programme à une autre, les variables de la liste peuvent porter des noms différents, • au sein d’une même unité de programme, un bloc COMMON (étiqueté ou non) peut être référencé plusieurs fois : les différentes listes de variables sont alors ajoutées les unes aux autres.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 192 / 262

Include
1 Introduction 2 Généralités 3 Déclarations 4 Opérateurs et expressions 5 Structures de contrôle 6 Tableaux 7 Entrées-Sorties 8 Procédures 9 Common 10 Include La directive INCLUDE
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	195 / 262

Annexe A : entrées-sorties - syntaxes
11 Annexe A : entrées-sorties - syntaxes 12 Annexe B : procédures intrinsèques 13 Annexe C : aspects obsolètes 14 Annexe D : système de compilation 15 Annexe E : exercices
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	198 / 262

Annexe A : entrées-sorties - syntaxes
Instruction OPEN
• STATUS : état du fichier avant l’ouverture, • OLD : le fichier doit exister, • NEW : le fichier ne doit pas exister, il sera créé, • UNKNOWN : état dépendant du compilateur, • REPLACE : si le fichier n’existe pas, il est créé et hérite de l’état "OLD", sinon, il est détruit et un nouveau fichier est créé, • SCRATCH : un fichier temporaire anonyme est créé, il sera détruit à la fin du programme ou au moment du CLOSE. • ACCESS : mode d’accès au fichier, • DIRECT : accès direct, • SEQUENTIAL : accès séquentiel.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 200 / 262

Annexe A : entrées-sorties - syntaxes
Instruction OPEN
• FORM : type du transfert, • FORMATTED : mode caractère (avec format), • UNFORMATTED : mode binaire (sans format). • RECL : longueur des enregistrements logiques en accès direct ou de l’enregistrement maximum en accès séquentiel. L’unité de longueur est le caractère pour les fichiers textes et dépend du processeur pour les fichiers binaires, • POSITION : positionnement dans le fichier après ouverture, • ASIS : positionnement inchangé si le fichier est déjà connecté, indéfini sinon, • REWIND : positionnement en tête de fichier, • APPEND : positionnement en fin de fichier pour extension, • ACTION : mode d’ouverture. • READ : seule la lecture est possible, • WRITE : seule l’écriture est possible, • READWRITE : la lecture ainsi que l’écriture sont permises,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 201 / 262
Annexe A : entrées-sorties - syntaxes
Instruction OPEN
• BLANK : indique la façon dont les blancs sont interprétés lors d’une opération d’entrée-sortie, • NULL : ils sont ignorés, • ZERO : ils sont interprétés comme des zéros, • DELIM : indique le caractère délimiteur utilisé pour les constantes chaînes de caractères écrites en format libre ou via une NAMELIST, • APOSTROPHE : délimiteur ?", • QUOTE : délimiteur ?’, • NONE : aucun délimiteur, • PAD : permet de gérer le padding lors d’une lecture, • YES : la liste de variables spécifiée dans l’instruction de lecture peut être plus grande que l’enregistrement logique, les variables non valorisées lors de la lecture sont remplies par des zéros pour les variables numériques ou logiques, par des blancs pour les variables de type chaîne de caractères, • NO : aucun padding n’est autorisé. La taille de l’enregistrement logique doit être suffisante pour permettre la valorisation des variables de la liste.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 202 / 262

Annexe A : entrées-sorties - syntaxes
Instruction READ
• ADVANCE : positionnement à partir duquel s’effectue l’entrée-sortie suivante : • YES? enregistrement suivant, • NO? suite de l’enregistrement courant, • END : étiquette de l’instruction à exécuter en cas de fin de fichier, • EOR : étiquette de l’instruction à exécuter en cas de fin d’enregistrement, • ERR : étiquette de l’instruction à exécuter en cas d’erreur, • IOSTAT : entier valorisé une fois l’entrée-sortie effectuée. Il est nul si l’opération s’est bien passée. Une valeur positive indique une erreur. Une valeur négative signale une fin de fichier dans le cas d’un accès séquentiel et l’absence d’enregistrement du rang spécifié si l’accès est direct, • REC : numéro de l’enregistrement à traiter pour un fichier à accès direct, • SIZE : entier récupérant le nombre de caractères traités si la fin d’enregistrement a été atteinte.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 204 / 262

Annexe A : entrées-sorties - syntaxes
Instruction WRITE
• ADVANCE : positionnement à partir duquel s’effectue l’entrée-sortie suivante : • YES? enregistrement suivant, • NO? suite de l’enregistrement courant, • ERR : étiquette de l’instruction à exécuter en cas d’erreur, • IOSTAT : entier valorisé une fois l’entrée-sortie effectuée. Il est nul si l’opération s’est bien passée, non nul sinon, • REC : numéro de l’enregistrement à traiter pour un fichier à accès direct.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 206 / 262

Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• UNIT : numéro de l’unité logique sur laquelle le fichier est connecté, • ACCESS : méthode d’accès • SEQUENTIAL si fichier connecté pour un accès séquentiel, • DIRECT si fichier connecté pour un accès direct, • UNDEFINED si fichier non connecté, • ACTION : type d’accès • READ si fichier connecté en lecture, • WRITE si fichier connecté en écriture, • READWRITE si fichier connecté en lecture/écriture, • UNDEFINED si fichier non connecté, • BLANK : • NULL si les blancs sont ignorés, • ZERO si les blancs sont interprétés comme des 0, • UNDEFINED si le fichier n’est pas connecté en mode formaté ou bien n’est pas connecté du tout,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 208 / 262

Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• DELIM : délimiteur pour les chaînes de caractères en sortie en format libre ou via namelist • APOSTROPHE délimiteur ?", • QUOTE délimiteur ?’, • UNDEFINED si le fichier n’est pas connecté en mode formaté ou bien n’est pas connecté du tout, • DIRECT : accès direct • YES l’accès direct est un mode d’accès permis, • NO l’accès direct n’est pas un mode d’accès permis, • UNKNOWN le compilateur ne sait pas si l’accès direct est permis ou non, • ERR : étiquette de l’instruction à exécuter en cas d’erreur, • EXIST : • .true. si le fichier ou l’unité logique existe, • .false. si le fichier ou l’unité logique n’existe pas, • FILE : nom du fichier pour lequel on souhaite avoir des informations,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 209 / 262
Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• FORM : type d’accès • FORMATTED si le fichier est connecté en mode formaté, • UNFORMATTED si le fichier est connecté en mode binaire, • UNDEFINED si le fichier n’est pas connecté, • FORMATTED : • YES si le traitement du fichier en mode formaté est valide • NO si le traitement du fichier en mode formaté n’est pas valide, • UNKNOWN lorsque le compilateur ne sait pas si le traitement du fichier en mode formaté est permis ou non, • IOSTAT : valeur de retour • >0 si une erreur s’est produite, • =0 si aucune erreur ne s’est produite, • NAME : nom du fichier connecté s’il a un nom, sinon valeur indéfinie,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 210 / 262

Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• NAMED : • .true. si le fichier a un nom, • .false. si le fichier est anonyme, • NEXTREC : • renvoie le numéro du prochain enregistrement à traiter si le fichier est ouvert en accès direct (1 si aucun enregistrement n’a déjà été traité, • renvoie une valeur indéfinie si le fichier n’a pas été ouvert en accès direct, • NUMBER : renvoie le numéro de l’unité logique sur laquelle le fichier est connecté (-1 s’il ne l’est pas), • OPENED : • .true. si le fichier est ouvert, • .false. si le fichier n’est pas ouvert, • PAD : • NO le fichier a été ouvert avec le paramètre PAD="NO", • YES le fichier a été ouvert avec le paramètre PAD="YES" ou bien le fichier n’est pas connecté,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 211 / 262
Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• POSITION : • REWIND si fichier ouvert avec un positionnement en tête, • APPEND si fichier ouvert avec un positionnement en fin, • ASIS si fichier ouvert sans changement de la position, • UNDEFINED si fichier non connecté ou bien connecté en accès direct, • READ : • YES un accès en lecture est permis, • NO un accès en lecture n’est pas permis, • UNKNOWN le compilateur ne sait pas si un accès en lecture est permis ou non, • READWRITE : • YES un accès en lecture/écriture est permis, • NO un accès en lecture/écriture n’est pas permis, • UNKNOWN le compilateur ne sait pas si un accès en lecture/écriture est permis ou non, • RECL : renvoie la taille de l’enregistrement logique maximum ou une valeur indéfinie si le fichier n’existe pas,
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 212 / 262

Annexe A : entrées-sorties - syntaxes
Instruction INQUIRE
• SEQUENTIAL : • YES l’accès séquentiel est un mode d’accès permis, • NO l’accès séquentiel n’est pas un mode d’accès permis, • UNKNOWN le compilateur ne sait pas si l’accès séquentiel est permis ou non, • UNFORMATTED : • YES si le traitement du fichier en mode binaire est valide • NO si le traitement du fichier en mode binaire n’est pas valide, • UNKNOWN lorsque le compilateur ne sait pas si le traitement du fichier en mode binaire est permis ou non, • WRITE : • YES un accès en écriture est permis, • NO un accès en écriture n’est pas permis, • UNKNOWN le compilateur ne sait pas si un accès en écriture est permis ou non.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 213 / 262

Annexe B : procédures intrinsèques
11 Annexe A : entrées-sorties - syntaxes 12 Annexe B : procédures intrinsèques 13 Annexe C : aspects obsolètes 14 Annexe D : système de compilation 15 Annexe E : exercices
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	216 / 262

Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• ABS : retourne la valeur absolue de son argument. Pour un complexe, retourne sa norme : ^px² + y². ABS(-1) = 1; ABS(-1.5) = 1.5; ABS((3.,4.)) = 5.0 • ACHAR : retourne le caractère de la table ASCII dont le rang est transmis en argument. ACHAR(88) = ’X’; ACHAR(42) = ’*’ • ACOS : retourne l’arc cosinus en radians de son argument réel. ACOS(0.54030231) = 1.0 • ADJUSTL : cadre à gauche la chaîne passée en argument : supprime les blancs en tête; complète à droite par des blancs. ADJUSTL(’^^Fortran’) = ’Fortran^^’ • ADJUSTR : cadre à droite la chaîne passée en argument : supprime les blancs en fin; complète à gauche par des blancs. ADJUSTR(’Fortran^^’) = ’^^Fortran’
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 217 / 262
Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• AIMAG : retourne la partie imaginaire du complexe passé en argument. AIMAG((2.,3.)) == 3.0 • AINT : tronque le réel passé en argument. AINT(2.783) = 2.0; AINT(-2.783) = -2.0 • ANINT : retourne, sous forme d’un réel, l’entier le plus proche du réel transmis. ANINT(2.783) = 3.0; ANINT(-2.783) = -3.0 • ASIN : retourne l’arc sinus en radians de son argument réel. ASIN(0.84147098) = 1.0 • ATAN : retourne l’arc tangente en radians de son argument réel. ATAN(1.5574077) = 1.0 • BIT_SIZE : retourne le nombre de bits utilisés pour la représentation de l’entier passé en argument. BIT_SIZE(1) = 32
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 218 / 262

Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• BTEST : permet de tester la valeur d’un bit d’un entier : l’entier ainsi que la position du bit à tester sont passés en argument. BTEST(8,3) = .true.; BTEST(10,2) = .false. • CEILING : retourne l’entier immédiatement supérieur au réel transmis en argument. CEILING(3.7) = 4, CEILING(-3.7) = -3 • CMPLX : retourne un complexe dont les parties réelle 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 passé en argument. CONJG((-3.0,4.0)) = -3.0-4.0i • COS : retourne le cosinus de l’angle passé en argument (exprimé en radians). COS(1.0) = 0.54030231 • COSH : retourne le cosinus hyperbolique. COSH(1.0) = 1.5430806
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 219 / 262
Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• DBLE : convertit en double précision l’argument transmis. • EXP : retourne l’exponentiel de l’argument transmis. EXP(1.0) = 2.7182818 • FLOOR : retourne l’entier immédiatement inférieur au réel transmis en argument. FLOOR(3.7) = 3, FLOOR(-3.7) = -4 • IACHAR : retourne le rang dans la table ASCII du caractère transmis en argument. IACHAR(’X’) = 88; IACHAR(’*’) = 42 • IAND : retourne l’entier dont la représentation binaire est obtenue en combinant à l’aide d’un "et logique" les bits des deux entiers transmis en argument. IAND(1,3) = 1; IAND(10,10) = 10 • IBCLR : permet de forcer à zéro un bit d’un entier : l’entier ainsi que la position du bit à forcer sont passés en argument. IBCLR(14,1) = 12 IBCLR((/ 1,2,3,4 /), 31) = (/ 29,27,23,15 /)
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 220 / 262

Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• IBITS : permet l’extraction d’une séquence de bits d’un entier. L’entier suivi de la position ainsi que la longueur pour effectuer l’extraction sont passés en argument. IBITS(14,1,3) = 7 • IBSET : permet de forcer à 1 un bit d’un entier : l’entier ainsi que la position du bit à forcer sont passés en argument. IBSET(12,1) = 14 IBSET((/ 1,2,3,4 /), 0) = (/ 1,3,3,5 /) • IEOR : retourne l’entier dont la représentation binaire est obtenue en combinant à l’aide d’un "ou exclusif" les bits des deux entiers transmis en argument. IEOR(1,3) = 2; IEOR(10,10) = 0 • INDEX : retourne la position d’une sous-chaîne dans une chaîne. La chaîne suivie de la sous-chaîne et du sens de la recherche sont fournis en argument. INDEX(’FORTRAN’,’R’) = 3 INDEX(’FORTRAN’,’R’,.) = 5
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 221 / 262
Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• INT : convertit en entier l’argument transmis. INT(-3.7) = -3; INT(9.1/4.0) = 2 • IOR : retourne l’entier dont la représentation binaire est obtenue en combinant à l’aide d’un "ou logique" les bits des deux entiers transmis en argument. IOR(1,3) = 3 IOR((/ 3,2 /),(/ 1,10 /)) = (/ 3,10 /) • ISHFT : permet d’effectuer un décalage des bits de l’entier passé en premier argument. Le deuxième argument indique le nombre de bits à décaler : son signe indique le sens du décalage (positif = gauche, négatif = droite). Les bits sortants sont perdus, les positions vacantes sont mises à zéro. ISHFT(3,1) = 6; ISHFT(3,-1) = 1 • ISHFTC : idem ISHFT à la différence que le décalage est circulaire et s’effectue sur les n bits de droite de l’entier , n étant fourni en troisième argument (s’il est absent il est considéré égal au nombre de bits de l’entier). ISHFT(3,2,3) = 5; ISHFT(3,-2) = -1073741824
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 222 / 262

Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• LEN : retourne la longueur de la chaîne de caractères transmise en argument. CHARACTER(len=10) CH; LEN(CH) = 10 • LEN_TRIM : retourne la longueur de la chaîne de caractères transmise en argument sans considérer les blancs de fin. LEN_TRIM(’^^FORTRAN^^^’) = 9; LEN_TRIM(’^^^’) = 0 • LGE : compare les deux chaînes de caractères transmises en argument : retourne .true. si la première chaîne est supérieure ou égale à la deuxième, .false. sinon. LGE(’MANET’,’MONET’) = .false. LGE(’MANET Edouard’,’MANET’) = .true. • LGT : compare les deux chaînes de caractères transmises en argument : retourne .true. si la première chaîne est supérieure strictement à la deuxième, .false. sinon. LGT(’MANET’,’MANET’) = .false. • LLE : compare les deux chaînes de caractères transmises en argument : retourne .true. si la première chaîne est inférieure ou égale à la deuxième, .false. sinon. LLE(’MANET’,’MONET’) = .true. LLE(’MANET’,’MANET’) = .true. • LLT : compare les deux chaînes de caractères transmises en argument : retourne .true. si la première chaîne est inférieure strictement à la deuxième, .false. sinon. LLT(’MANET’,’MANET’) = .false.
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 223 / 262
Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• LOG : retourne le logarithme népérien de l’argument transmis. LOG(2.7182818) = 1.0; LOG(10.0) = 2.3025851 • LOG10 : retourne le logarithme décimal de l’argument transmis. LOG10(10.0) = 1.0; LOG10(10.E10) = 11.0 • MAX : retourne le maximum des nombres passés en argument. MAX(-9.0,7.0,2.0) = 7.0 • MIN : retourne le minimum des nombres passés en argument. MIN(-9.0,7.0,2.0) = -9.0 • MOD : retourne le reste de la division effectuée à l’aide des deux arguments fournis. MOD(3.0,2.0) = 1.0; MOD(-8,5) = -3 • NOT : retourne l’entier dont la représentation binaire est obtenue en inversant les bits de l’entier transmis en argument. NOT(10) = -11 • REAL : convertit en réel l’argument transmis. REAL(3) = 3.0 • REPEAT : permet de concaténer n fois une chaîne de caractères. REPEAT(’A’,10) = ’AAAAAAAAAA’ • SCAN : retourne la position du premier caractère d’une chaîne figurant parmi un ensemble de caractères donné. La recherche peut être faite dans les deux sens. SCAN(’RENOIR’,’OI’) = 4 SCAN(’RENOIR’,’OI’,.) = 5
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 224 / 262

Annexe B : procédures intrinsèques
Principales procédures intrinsèques
• SIGN : retourne le nombre dont la valeur absolue est celle du premier argument et le signe celui du deuxième. SIGN(-3.0,2.0) = 3.0 • SIN : retourne le sinus de l’angle passé en argument (exprimé en radians). SIN(1.0) = 0.84147098 • SINH : retourne le sinus hyperbolique. SINH(1.0) = 1.1752012 • SQRT : retourne la racine carré de son argument. SQRT(5.0) = 2.236068010 • TAN : retourne la tangente de l’angle passé en argument (exprimé en radians). TAN(1.0) = 1.5574077 • TANH : retourne la tangente hyperbolique. TANH(1.0) = 0.76159416 • TRIM : retourne la chaîne de caractères transmise débarrassée de ses blancs de fin. TRIM(’PICASSO^^^^^’) = ’PICASSO’ • VERIFY : retourne la position du premier caractère d’une chaîne ne figurant pas parmi un ensemble de caractères donné. La recherche peut être faite dans les deux sens. VERIFY(’RENOIR’,’OI’) = 1 VERIFY(’RENOIR’,’OI’,.) = 6
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 225 / 262
Annexe C : aspects obsolètes
11 Annexe A : entrées-sorties - syntaxes 12 Annexe B : procédures intrinsèques 13 Annexe C : aspects obsolètes 14 Annexe D : système de compilation 15 Annexe E : exercices
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	226 / 262

Annexe C : aspects obsolètes
Aspects obsolètes I
1 IF arithmétique : IF (ITEST) 10,11,12 ==>IF--THEN--ELSE IF--ELSE--ENDIF 2 Branchement au END IF depuis l’extérieur (*) ==> se brancher à l’instruction suivante. 3 Boucles DO pilotées par réels : DO 10 R=1., 5.7, 1.3 4 Partage d’une instruction de fin 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		(*)
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	227 / 262
Annexe C : aspects obsolètes
Aspects obsolètes II
6 ASSIGN et le GO TO assigné : () ASSIGN10 TO intvar .* ASSIGN20 TO intvar . GO TOintvar ==>SELECT CASE ou IF/THEN/ELSE() : aspects obsolètes déclarés hors norme par Fortran 95 7 ASSIGN d’une étiquette de FORMAT : () ASSIGN 2 TO NF CHARACTER(7),DIMENSION(4)::C 2 FORMAT (F9.2) ==> I = 2; C(2) = ’(F9.2)’ PRINT NF,TRUC PRINT C(I),TRUC 8 RETURN multiples :
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013 228 / 262

Annexe C : aspects obsolètes
Aspects obsolètes III
CALL SP1(X,Y,10,20) 10 20 SUBROUTINE SP1(X1,Y1,,) RETURN 1 RETURN 2 ==>SELECT CASE sur la valeur d’un argument retourné 9 PAUSE ’Montez la bande 102423 SVP’ () ==>READ qui attend les données 10 FORMAT(9H A éviter) () ==> Constante littérale : FORMAT(’ Recommandé’) (*) : aspects obsolètes déclarés hors norme par Fortran 95
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	229 / 262
Annexe C : aspects obsolètes
Aspects obsolètes Fortran 95
1 Le "format fixe" du source ==>"format libre". 2 Le GO TO calculé (GO TO (10,11,12, ), int_expr) ==>select case. 3 L’instruction DATA placée au sein des instructions exécutables ==> avant les instructions exécutables. 4 Statement functions (sin_deg(x)=sin(x3.14/180.)) ==> procédures internes. 5 Le type CHARACTER dans les déclarations ==>CHARACTER(LEN= ) 6 Le type CHARACTER(LEN=*) de longueur implicite en retour d’une fonction ==>CHARACTER(LEN=len(str)).
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))	18 février 2013	230 / 262

Annexe D : système de compilation
11 Annexe A : entrées-sorties - syntaxes 12 Annexe B : procédures intrinsèques 13 Annexe C : aspects obsolètes 14 Annexe D : système de compilation 15 Annexe E : exercices
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fo)	rtran(F95-1)	18 février 2013	231 / 262
Annexe D : système de compilation
Système de compilation
La commande f90 permet de générer un exécutable à partir de fichiers sources Fortran. Celle-ci appelle un système de compilation faisant successivement appel à : • un préprocesseur, • un compilateur, • un loader ou éditeur de liens. La composante préprocesseur transforme le source Fortran en entrée au moyen de directives. La composante compilateur analyse le source Fortran fourni (éventuellement transformé à l’étape précédente) avec : • détection des erreurs de syntaxe, • traduction du source en langage machine plus ou moins optimisé, • production d’un module objet. Enfin la dernière composante fait appel au loader qui récupère les modules objets précédemment créés et les regroupe pour produire un module exécutable. Les différentes unités de programme constituant une application Fortran peuvent figurer dans un même fichier ou bien être réparties dans plusieurs fichiers. Ceux-ci doivent être suffixés par .f ou .f90 .
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 232 / 262

Annexe E : exercices

11 Annexe A : entrées-sorties - syntaxes

12 Annexe B : procédures intrinsèques

13 Annexe C : aspects obsolètes

14 Annexe D : système de compilation

15 Annexe E : exercices

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fo)

rtran(F95-1)

18 février 2013

235 / 262

Annexe E : exercices

Énoncés

Exercice 1

Écrire un programme permettant de résoudre le système de 2 équations à 2 inconnues :

nu₁x + v₁y = w₁u₂x + v₂y = w₂

On pourra imprimer les solutions à l’aide de l’instruction : PRINT *, ’X = ’, X, ’, Y = ’, Y

Exercice 2

Écrire un programme permettant de calculer les racines du trinôme du 2^nd degré : ax² +bx +c. On s’assurera que a est non nul. Les racines, si elles existent, pourront être imprimées à l’aide de l’instruction :

PRINT *, ’X1 = ’, X1, ’, X2 = ’, X2

Exercice 3

Écrire un programme calculant le nombre d’Or. Celui-ci peut être obtenu à partir de la suite de Fibonnacci u_n définie par :

u₀ = 1 u₁ = 1

un+1 = un +un?1

La suite ( ⁿ_u⁺_n¹ ) converge vers le nombre d’Or.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 236 / 262

Annexe E : exercices

Énoncés

Exercice 4

Écrire un programme permettant de déterminer les nombres premiers dans l’intervalle [1,n] à l’aide du crible d’Ératosthène. Il consiste à former une table avec tous les entiers naturels compris entre 2 et n et à rayer (mise à zéro), les uns après les autres, les entiers qui ne sont pas premiers de la manière suivante : dès que l’on trouve un entier qui n’a pas encore été rayé, il est déclaré premier, et on raye tous les multiples de celui-ci.

À la fin du procédé, les nombres non barrés sont des nombres premiers.

On tiendra compte du fait qu’un nombre donné peut déjà avoir été éliminé en tant que multiple de nombres précédents déjà testés.?

Par ailleurs, on sait que l’on peut réduire la recherche aux nombres de? ? 2 à n (si un entier non premier est strictement supérieur

à n alors il a au moins un diviseur inférieur à n et aura donc déjà été rayé).

Exercice 5

Écrire un programme permettant de trier un vecteur de nombres en ordre croissant puis décroissant. On s’appuiera sur l’algorithme appelé tri à bulle qui consiste à comparer 2 éléments consécutifs et à les intervertir si nécessaire.

Si après avoir terminé l’exploration du tableau au moins une interversion a été effectuée, on renouvelle l’exploration, sinon le tri est terminé.

Exercice 6

Écrire un programme permettant d’effectuer le produit de 2 matrices A et B. Leurs profils seront définis à l’aide de constantes symboliques. La matrice résultat C sera imprimée à l’écran ligne par ligne avec l’instruction PRINT puis stockée dans un fichier binaire que l’on nommera « exo6.matrice ».

Exercice 7

Le fichier texte séquentiel « musiciens » est constitué de plusieurs enregistrements, chacun contenant un nom de musicien suivi de ses années de naissance et de mort.

Écrire un programme dont le but est de lire le fichier « musiciens » et de stocker les enregistrements lus dans un fichier texte à accès direct que l’on nommera « ».

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 237 / 262

Annexe E : exercices

Énoncés

Exercice 8

Imprimer l’enregistrement du fichier « musiciens » dont le rang est entré au clavier. Son extraction sera effectuée à partir d’un fichier texte temporaire à accès direct, image du précédent. On permettra la saisie de plusieurs rangs.

Exercice 9

Les enregistrements des fichiers séquentiels

« » et « » sont constitués d’une date de naissance (ou de décès) d’un musicien suivi de son rang dans le fichier « » créé à l’exercice 7.

Écrire un programme permettant d’imprimer le ou les musiciens dont la date de naissance ou de mort est saisie au clavier. Le type de date désirée sera préalablement déterminé.

La sélection des enregistrements répondant aux choix spécifiés, s’effectuera par l’intermédiaire du fichier d’index correspondant au type de date.

On offrira la possibilité d’effectuer plusieurs recherches.

Exercice 10

Le but de cet exercice est de transformer la matrice stockée dans le fichier binaire « exo6.matrice ». Cette transformation consiste à modifier chaque élément à l’aide d’une fonction paramétrable de la forme y = f (x).

On définira plusieurs fonctions de ce type. La valeur d’un entier lu dans une namelist indiquera la fonction à transmettre en argument de la procédure chargée d’effectuer la transformation.

Exercice 11

Trier les vecteurs lignes puis les vecteurs colonnes d’une matrice en utilisant l’algorithme tri à bulle et la matrice stockée dans le fichier binaire « exo6.matrice ».

On se définira une procédure effectuant le tri (croissant ou décroissant) des différents vecteurs au moyen d’une procédure interne.

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw

f.int Langage Fortran(F95-1))

18 février 2013 238 / 262

Annexe E : exercices		– Symboles – .. 173 ..171 direct 137, 139, 141 exemple 143 séquentiel . 97, 99, 101 ar 235 chaîne de caractères ..171 procédure .. 175 tableau ..173 arguments d’appel .. 165, 167, 169 attribut .. 37 DIMENSION 81 hexadécimale 17 octal .. 17 bases de numération .. 17 bibliographie 11 bloc .. 95 exemple . 191
assumed-size array assumed-size string – A – accès ANSI .. 9 argument argument procédure . 177 arguments muets . 165 ASA 9 assign 229 – B – BACKSPACE . 151 base bibliothèque 235 Block data . 189 buffer . 95 – C – CALL 167 caractère
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262
Annexe E : exercices		représentation en mémoire 25 table ASCII ..27 CHARACTER* 231 CLOSE .. 97 exemple . 217 IOSTAT= .. 215 STATUS= ..215 UNIT= ..215 jeu de caractères 29 étiqueté . 189 attribut save 191, 193 initialisation 189, 191 blanc ..185, 187 exemple 187 initialisation .. 187 règles et restrictions 193, 195 syntaxe ..185 représentation en mémoire 23 chaînes de caractères ..45 complexes 45 entières 41 littérales 41, 43, 45 réelles double précision 43 réelles simple précision 43 symboliques . 49 attribut PARAMETER 49 character . 39 implicit none .41 initialisation avec ’=’ ..49 instruction equivalence 51 exemple 51, 53 syntaxe 39
code source Common 185, 187, 189, 191, 193, 195 compilateur 233 complexe constantes CONTAINS 177 – D – déclaration
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262

Annexe E : exercices		tableau 81 descripteurs de format .. 101 Durée de vie et visibilité des identificateurs .181 représentation en mémoire 19 exercice 1 . 237 exercice 10 239 exercice 11 239 exercice 2 . 237 exercice 3 . 237 exercice 4 . 239 exercice 5 . 239 exercice 6 . 239 exercice 7 . 239 exercice 8 . 239 exercice 9 . 239 exercice 1 . 241 exercice 10 259 exercice 11 263 exercice 2 .. 241, 243 exercice 3 . 243 exercice 3 (autre solution) .245 exercice 4 . 245 exercice 4 (autre solution) .247 exercice 5 . 247 exercice 6 . 249 exercice 7 . 251 exercice 8 . 251 exercice 9 . 253
DATA .. 231 DELIM= 135 – E – ENDFILE .. 151 enregistrement logique 95 entier entrée standard 157 equivalence ..51 exercices énoncés corrigés EXTERNAL 175
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262
Annexe E : exercices		binaire ..99, 139 destruction . 147 interne .. 147 temporaire ..145 texte .. 101, 141 FMT= ..101 statement function 231 123 BOZ . 157 descripteur A en écriture 121 descripteur A en lecture . 109 descripteur EN en écriture ..117 descripteur ES en écriture .. 119 descripteur F en écriture 113 descripteur I en écriture . 113 descripteur I en lecture .. 105 descripteur L en écriture .121 descripteur L en lecture . 109 en écriture 111 en lecture . 105 descripteurs / ..127 descripteurs de contrôle . 125 descripteurs E, D en écriture .. 115 descripteurs F en lecture 107 descripteurs F, E, D en lecture .107 descripteurs SS,SP,S . 119 facteur de répétition . 127 gabarit indéfini .115 instruction ..159 libre ..131 réexploration .. 129 format fixe . 231 format libre 231 documentation ..13
– F – fichier fonction format Litteral string descripteurs formats d’édition . 101 Fortran
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262

Annexe E : exercices		fortran 2003 .. 9 fortran 2008 .. 9 fortran 66 ..9 fortran 77 ..9 fortran 90 ..9 fortran 95 ..9 fortran IV ..9 fortran V .. 9 aspects obsolètes 229, 231 FUNCTION 169 identificateur 35 durée de vie 181 visibilité . 181 instruction DATA .. 47 ACCESS= ..209 ACTION= ..209 BLANK= .. 209 DELIM= 211 DIRECT= ..211 ERR= 211 EXIST= .211 FILE= .. 211 FORM= .211 FORMATTED= .. 211 IOSTAT= .. 211 NAME= 211 NAMED= ..213 NEXTREC= 213 NUMBER= 213 OPENED= .213
Fortran 95 – G – GO TO calculé 231 – I – identificateurs INCLUDE ..197 initialisation INQUIRE .. 155
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262
Annexe E : exercices		PAD= .. 213 POSITION= .. 213 READ= . 213 READWRITE= 213 RECL= . 213 SEQUENTIAL= .. 215 syntaxe ..209 UNFORMATTED= .. 215 UNIT= ..209 WRITE= 215 iolength= .. 145 GO TO 71 include .. 197 positionnement 151 IOSTAT ..97 LEN= .. 171 loader .. 233 représentation en mémoire 25 make 235
inquire instruction instructions INTRINSIC 175 – L – logique – M – module exécutable 233 module objet ..233 – N – NAMELIST . 101, 135 NML= 101, 135 – O – opérateurs
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262

Annexe E : exercices		conversion implicite .. 57 concaténation 61 d’affectation . 63 logiques .. 61 relationnels .. 59 table des priorités .. 63 ACCESS= ..201 ACTION= ..203 BLANK= .. 203 DELIM= 203 exemple . 217 FILE= .. 201 FORM= .203 IOSTAT= .. 201 PAD= .. 203 POSITION= .. 203 RECL= . 203 STATUS= ..201 syntaxe ..201 UNIT= ..201 fonction . 169 interne .. 177 intrinsèque . 183 subroutine ..167 ABS . 219 ACHAR .. 171, 219 ACOS 219 ADJUSTL ..219 ADJUSTR ..219 AIMAG ..219 AINT 219 ANINT ..219 ASIN .219
arithmétiques OPEN 97, 99 – P – préprocesseur ..233 PRINT ..157 procédure procédures intrinsèques
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262
Annexe E : exercices		ATAN 219 BIT_SIZE ..219 BTEST . 221 CEILING 221 CMPLX . 221 CONJG . 221 COS . 221 COSH 221 DBLE 221 EXP . 221 FLOOR . 221 IACHAR ..171, 221 IAND 221 IBCLR .. 221 IBITS 223 IBSET .. 223 IEOR .223 INDEX .. 223 INT ..223 IOR ..223 ISHFT .. 223 ISHFTC .223 LEN . 225 LEN_TRIM 225 LGE ..225 LGT . 225 LLE ..225 LLT ..225 LOG . 225 LOG10 .. 225 MAX .225 MIN . 225 MOD 225 NOT .225 REAL 225 REPEAT 225 SCAN 225 SIGN .227 SIN .. 227 SINH .227 SQRT 227

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262

Annexe E : exercices		TAN . 227 TANH 227 TRIM 227 VERIFY .227 précision ..37 représentation en mémoire 19 ADVANCE= 205 END= ..159, 161, 205 EOR= .. 205 ERR= .159, 205 FMT= .. 205 IOSTAT= 163, 205 NML= .. 205 REC= 205 SIZE= .. 205 syntaxe ..205 UNIT= ..205 des caractères 25 des complexes .. 23 des entiers 19 des logiques . 25 des réels ..19 syntaxe . 71 DO indéxé 73 DO WHILE ..73 DO/CYCLE . 77
– R – réel READ REC= ..137, 139, 141 représentation en mémoire return .167, 169 REWIND .. 151 – S – scratch . 145 sortie standard 157 structures de contrôle DO
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262
Annexe E : exercices		DO/EXIT 75 IF ..67 SELECT CASE . 69 commentaire .33 format fixe 31 format libre ..31 étendue .. 83 agencement en mémoire ..85 conformance .83 constructeur de vecteur 87 déclaration 81 expression 89 instruction DATA . 89 symbole ’=’ 85 profil .. 83 rang 83 section régulière .91 IF ..67 SELECT CASE . 69 Types prédéfinis 37 unité logique 97 type 37
syntaxe – T – tableau initialisation tampon .. 95 tests – U – UNIT=* 157 unités de programme . 29 – V – variable – W – WRITE
Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262

Annexe E : exercices		ADVANCE= 207 ERR= 207 FMT= .. 207 IOSTAT= .. 207 NML= .. 207 REC= 207 syntaxe ..207 UNIT= ..207

Anne Fouilloux Patrick Corde ( anne.fouilloux@ecmw	f.int Langage Fortran(F95-1))		18 février 2013 262 / 262