ÉLÉMENTS DE PROGRAMMATION EN FORTRAN - 77

ECOLE D ' INGENIEURS DE FRIBOURG

SECTION DE MECANIQUE

COURS D ' INFORMATIQUE : SECONDE ANNEE

ÉLÉMENTS DE PROGRAMMATION

EN

FORTRAN - 77

EDITION 1992

G. Nicolet , EIF Fribourg

Table des matières

Page PRESENTATION 1 Chapitre 1 INTRODUCTION A FORTRAN-77 5 1.1 Caractères et instructions 6 1.1.1 Caractères du langage 6 1.1.2 Champ pour instructions 7 1.2 Configuration d'un programme 8 1.2.1 Hiérarchie des instructions 9 1.2.2 Instructions de spécification 9 1.2.3 Instructions exécutables 10 1.2.4 Unités de programme 10 1.2.4.1 Identificateurs 10 1.2.4.2 Programme principal 11 1.2.4.3 Sous-programmes 11 Chapitre 2 EXPRESSIONS FORTRAN 12 2.1 Types de données 12 2.1.1 Occupation en mémoire des différents types 13 2.1.2 Type entier : integer 14 2.1.3 Type réel : real 14 2.1.4 Type : double precision 15 2.1.5 Type complexe : complex 16 2.1.6 Type booléen ou logique : logical 16 2.1.7 Type caractère : character 17 2.2 Constantes FORTRAN 17 2.2.1 Constantes entières 17 2.2.2 Constantes réelles 17 2.2.3 Constantes en double précision 18 2.2.4 Constantes complexes 18 2.2.5 Constantes entières non décimales 19 2.2.5.1 DOMAIN 19 2.2.5.2 MS-FORTRAN 19 2.2.5.3 VAX-11 20 2.2.6 Constantes logiques 20 2.2.7 Constantes chaîne de caractères 20 2.2.8 Constantes Hollerith 21 2.3 Variables simples 21 2.3.1 Spécification de type par implicit 22 2.3.2 Variable de type integer 22 2.3.3 Variables de type real 23 2.3.4 Variables de type double precision 23 2.3.5 Variables de type complex 24 2.3.6 Variables de type logical 24 2.3.7 Variables de type character 24 2.4 Variables de tableaux 25

Table : 1

4.1 Déclaration d'une variable indicée 25 2.4.2 Variables de type integer 26 2.4.3 Variables de type real 26 2.4.4 Variables de type double precision 27 2.4.5 Variables de type complex 27 2.4.6 Variables de type logical 27 2.4.7 Variables de type character 28 2.4.8 Rangement des éléments d'une variable 28 2.4.9 Instruction dimension 29 2.5 Expressions FORTRAN 29 2.5.1 Expressions arithmétiques 30 2.5.1.1 Opérateurs arithmétiques 30 2.5.1.2 Règles h'homogénéité des types 31 2.5.1.3 Exponentiation 32 2.5.2 Expressions de type character 33 2.5.2.1 Concaténation 33 2.5.2.2 Sous-chaînes de type character 33 2.5.3 Expressions de relation 34 2.5.4 Expressions logiques 35 2.5.4.1 Opérateurs logiques 35 2.5.4.2 Priorité des opérateurs 36 2.5.4.3 Exemples 36 Chapitre 3 INSTRUCTIONS DE BASE 38 3.1 Structures séquentielles 38 3.1.1 Instruction parameter 38 3.1.2 Instruction data 39 3.1.3 Affectation arithmétique 39 3.1.4 Affectation logique 41 3.1.5 Affectation d'une chaîne de caractères 41 3.1.6 Lecture de données 42 3.1.7 Affichage des données et des textes 44 3.1.8 Instruction : continue 45 3.1.9 Instruction : end 45 3.1.10 Instructions d'arrêt 45 3.1.10.1 Instruction : pause 45 3.1.10.2 Instruction : stop 47 3.2 Structures sélectives 47 3.2.1 Sauts inconditionnels 47 3.2.1.1 Go to inconditionnel 48 3.2.1.2 Go to imposé 48 3.2.1.3 Go to calculé 49 3.2.2 Instruction : if ... arithmétique 51 3.2.3 Instruction : if ... logique 52 3.2.4 Instructions avec bloc if 52 3.2.4.1 Configuration générale 52 3.2.4.2 Bloc if ... simple 53 3.2.4.3 Bloc if ... et else 53 3.2.4.4 Bloc if ... et else if ... 54 3.2.4.5 Remplacement de l'instruction : if arithmétique 54

Table : 2

2.4.6 Structure générale 54 3.2.4.7 Blocs if ... imbriqués 55 3.2.5 Exemple de programme 55 3.3 Structures itératives 58 3.3.1 Structure à compteur 58 3.3.1.1 Forme fondamentale 58 3.3.1.2 Contrôle du nombre d'itérations 59 3.3.1.3 Boucles imbriquées 59 3.3.1.4 Exemple de boucles do 60 3.3.1.5 Boucle do implicite 61 3.3.2 Structure tant que 62 3.3.2.1 Instruction : do while 62 3.3.2.2 Exemple de structure do while 62 Chapitre 4 SOUS-PROGRAMMES FORTRAN-77 65 4.1 Librairie FORTRAN 66 4.1.1 Identificateurs des fonctions 66 4.1.1.1 Référence intrinsic 66 4.1.1.2 Référence generic 66 4.1.2 Description des fonctions 67 4.1.2.1 Fonctions de conversion 67 4.1.2.2 Conversion entre entiers et caractères 67 4.1.2.3 Fonctions mathématiques élémentaires 68 4.1.2.4 Fonctions sur des expressions complexes 69 4.1.2.5 Fonctions mathématiques générales 69 4.1.2.6 Fonctions trigonométriques 70 4.1.2.7 Fonctions hyperboliques 71 4.1.2.8 Fonctions de manipulation de chaînes 71 4.1.2.9 Comparaison logique des chaînes 72 4.1.3 Table des fonctions de la librairie FORTRAN 72 4.2 Listes de paramètres 76 4.2.1 Paramètres formels et effectifs 76 4.2.1.1 Paramètres effectifs 76 4.2.1.2 Paramètres formels 77 4.2.2 Correspondance entre les listes 78 4.2.3 Transmission des variables de tableaux 79 4.2.3.1 Dimensions des variables indicées 79 4.2.3.2 Dimensions ajustables 79 4.2.3.3 Stockage des données 82 4.2.3.4 Dimensionnement par l'astérisque 85 4.2.4 Appel et retour d'un sous-programme 88 4.2.4.1 Instruction d'appel d'une procédure 88 4.2.4.2 Retour d'un sous-programme 88 4.2.4.3 Transmission d'étiquettes 89 4.3 Fonctions-formules 89 4.3.1 Définition de la fonction-formule 89 4.3.2 Appel de la fonction-formule 90 4.3.3 Exemples de fonctions-formules 90 4.3.4 Exemple de programme 91 4.4 Sous-programme : subroutine 92 4.4.1 Syntaxe de la définition 92

Table : 3

4.2 Configuration générale 93 4.4.3 Exemple de multiplication matricielle 94 4.5 Sous-programme : function 97 4.5.1 Syntaxe de la définition 97 4.5.2 Appel de la fonction 98 4.5.3 Exemple d'utilisation d'une fonction 98 4.6 Entrées et zones communes 100 4.6.1 Entrées additionnelles 100 4.6.1.1 Syntaxe de l'instruction entry 100 4.6.1.2 Entry dans un sous-programme subroutine 100 4.6.1.3 Entry dans un sous-programme function 101 4.6.2 Paramètres procéduraux 103 4.6.2.1 Exemple de paramètre procédural 103 4.6.2.2 Fonctions de la librairie en paramètre 104 4.6.3 Zones de réservation commune 105 4.6.3.1 Instruction common "blanc" 105 4.6.3.2 Instruction common identifié 106 4.6.4 Sauvegarde par l'instruction save 107 4.6.5 Adresses équivalentes en mémoire 108 4.6.5.1 Syntaxe de l'instruction 108 4.6.5.2 Equivalence de tableaux numériques 108 4.6.5.3 Equivalence de chaînes de caractères 109 4.6.5.4 Equivalence et common 109 4.6.6 Sous-programme block data 110 Chapitre 5 MISE EN FORME DES DONNEES 112 5.1 Mise en forme des entréées - sorties 112 5.1.1 Instruction de mise en forme 112 5.1.1.1 Instruction format 112 5.1.1.2 Descripteurs d'édition 113 5.1.1.3 Mise à la ligne ou à la page 113 5.1.1.4 Codes de lecture ou d'écriture 114 5.1.1.5 Mise en forme des données 115 5.1.2 Descripteurs de constantes et variables 115 5.1.2.1 Descripteur pour type integer 115 5.1.2.2 Descripteur G pour type real 116 5.1.2.3 Descripteur F pour type real 118 5.1.2.4 Descripteurs E et D pour type real 118 5.1.2.5 Facteur de multiplication 120 5.1.2.6 Descripteur L pour type logical 120 5.1.2.7 Descripteur A pour caractères 121 5.1.2.8 Descripteur H pour chaînes de caractères 122 5.1.2.9 Descripteur Z pour constantes hexadécimales 123 5.1.3 Descripteurs de mise en page 124 5.1.3.1 Saut de colonnes : descripteur X 124 5.1.3.2 Saut d'enregistrement : descripteur / 124 5.1.3.3 Tabulateur 125 5.1.3.4 Interruption du contrôle de la transmission 126 5.1.3.5 Répétition des descripteurs 126 5.1.3.6 Exploration de la mise en forme 126

Table : 4

1.4 Possibilités complémentaires 128 5.1.4.1 Choix de la réponse 128 5.1.4.2 Ecriture de la mise en forme 129 5.1.4.3 Edition des entités complexes 129 5.1.4.4 Champ de descripteurs par défaut 129 5.1.4.5 Lecture des cartes perforées 130 5.1.4.5 Spécificateurs variables de mise en forme 130 5.2 Lecture et écriture 132 5.2.1 Listes d'entrée et de sortie 132 5.2.1.1 Liste simple 132 5.2.1.2 Liste à boucle implicite 132 5.2.2 Lecture par l'instruction read 133 5.2.2.1 Syntaxe de l'instruction 133 5.2.2.2 Exemples de lecture 134 5.2.3 Ecriture de données 134 5.2.3.1 Syntaxe de l'instruction 135 5.2.3.2 Exemples d'écriture 135 5.2.4 Exemple de programme 136 Chapitre 6 LES FICHIERS FORTRAN 139 6.1 Généralités sur les fichiers 139 6.1.1 Description des genres de fichiers 140 6.1.1.1 Enregistrements 140 6.1.1.2 Fichiers externes 140 6.1.1.3 Fichiers internes 140 6.1.1.4 Modes d'accès 141 6.1.2 Clauses 141 6.1.2.1 Mode d'accès : access 142 6.1.2.2 Traitement des blancs : blank 142 6.1.2.3 Contrôle du mode d'accès : direct 142 6.1.2.4 Fin de fichier : end 142 6.1.2.5 Contrôle des erreurs : err 143 6.1.2.6 Existance d'un fichier : exist 143 6.1.2.7 Nom du fichier : file 143 6.1.2.8 Nature de l'enregistrement : form 144 6.1.2.9 Contrôle du codage : formatted 144 6.1.2.10 Mise en forme : fmt 144 6.1.2.11 Etat des entrées-sorties : iostat 145 6.1.2.12 Contrôle du nom : name et named 145 6.1.2.13 Numéro d'enregistrement : nextrec 145 6.1.2.14 Numéro d'unité logique : number 146 6.1.2.15 Contrôle de l'ouverture : opened 146 6.1.2.16 Spécification du numéro d'enregistrement : rec 146 6.1.2.17 Longueur de l'enregistrement : recl 146 6.1.2.18 Contrôle du mode séquentiel : sequential 146 6.1.2.19 Etat du fichier : status 147 6.1.2.20 Contrôle du codeage : unformatted 147 6.1.2.21 Spécification de l'unité : unit 147 6.1.3 Ouverture des fichiers 148 6.1.3.1 Instruction d'ouverture : open 148 6.1.3.2 Utilisation de l'ouverture 149

Table : 5

1.3.3 Exemple d'ouverture d'un fichier 149 6.1.3.4 Fermeture des fichiers 150 6.1.4 Ecriture, lecture et contrôle des fichiers 151 6.1.4.1 Ecriture de données dans un fichier 151 6.1.4.2 Lecture de données dans un fichier 151 6.1.4.3 Instruction inquire 152 6.1.5 Instructions complémentaires 153 6.1.5.1 Réinitialisation d'un fichier 153 6.1.5.2 Marque de fin de fichier 153 6.1.5.3 Recul d'un enregistrement 154 6.2 Fichiers à accès séquentiel 154 6.2.1 Opérations sur les fichiers séquentiels 154 6.2.1.1 Ouverture du fichier séquentiel 154 6.2.1.2 Ecriture du fichier séquentiel 155 6.2.1.3 Lecture du fichier séquentiel 156 6.2.1.4 Contrôle de la transmission des données 156 6.2.1.5 Exemple d'un fichier séquentiel 156 6.2.2 Algorithmes de traitement 158 6.2.2.1 Classement des fichiers 158 6.2.2.2 Longueur des enregistrements 159 6.2.2.3 Lecture d'un enregistrement à choix 161 6.2.2.4 Extension d'un fichier existant 161 6.2.2.5 Tableaux condensés 161 6.2.3 Les fichiers de texte 162 6.2.3.1 Ecriture et lecture d'un fichier texte 162 6.2.3.2 Exemple de lecture 162 6.2.3.3 Accès aux périphériques 164 6.2.4 Fichiers internes 164 6.2.4.1 Transfert de données 164 6.2.4.2 Exemple de transformation 165 6.3 Fichiers à accès direct 166 6.3.1 Opérations sur les fichiers à accès direct 166 6.3.1.1 Ouverture du fichier à accès direct 166 6.3.1.2 Ecriture d'un fichier à accès direct 167 6.3.1.3 Lecture d'un fichier à accès direct 168 6.3.2 Utilisation d'un fichier à accès direct 170 6.3.2.1 Présentation du programme 170 6.3.2.2 Instructions du programme 170 6.3.2.3 Particularités des instructions 174 Chapitre 7 REPRÉSENTATIONS GRAPHIQUES 176 7.1 Graphiques sur traceur HP 7475 A 176 7.1.1 Description du traceur HP 7475 A 176 7.1.1.1 Syntaxe du langage HP-GL 176 7.1.1.2 Zone de traçage 177 7.1.1.3 Systèmes d'unités 177 7.1.1.4 Points de cadrage 177 7.1.2 Instructions graphiques 177 7.1.3 Exemples de graphiques 179 7.1.3.1 Procédure d'initialisation 180 7.1.3.2 Direction de l'écriture 181

Table : 6

1.3.3 Représentation d'une fonction 182 7.1.3.4 Représentation d'une courbe fermée 184 7.1.3.5 Remarques complémentaires 186 7.2 Langage Postscript 187 7.2.1 Base du Langage 187 7.2.1.1 Unités graphiques 187 7.2.1.2 Pile dans Postscript 188 7.2.1.3 Opérateurs mathématiques 189 7.2.1.4 Graphiques élémentaires 190 7.2.1.5 Sous-programmes 192 7.2.2 Constructions graphiques 194 7.2.2.1 Instructions pour les graphiques 194 7.2.2.2 Instructions pour les textes 197 7.2.2.3 Instructions pour la programmation Fortran 199 7.2.2.4 Exemple d’utilisation du langage Postscript 202 7.3 Implémentation en FORTRAN 203 7.3.1 Implémentation : DOMAIN FORTRAN 204 7.3.1.1 Particularités 204 7.2.1.2 Directives de compilation 205 7.3.1.3 Développement de programmes 206 7.3.2 Implémentation : MS-FORTRAN 208 7.3.2.1 Particularités 208 7.3.2.2 Directives de compilation 211 7.3.2.3 Développement de programmes 212 7.3.2.4 Instructions complémentaires 214 7.3.2.5 Instructions pour graphiques é l’écran 218 7.3.3 Implémentation : VAX-11 FORTRAN 219 7.3.3.1 Particularités 219 7.3.3.2 Directives de compilation 220 7.3.3.3 Développement de programmes 221 7.3.3.4 Séquences de contrôle escape 223 Code ASCII 225 Index des instructions et des fonctions FORTRAN 227

Cet ouvrage ne peut être reproduit, même partiellement et sous quelque forme que ce soit, sans autorisation écrite de l'auteur

Table : 7

Table : 8

PRÉSENTATION L'introduction d'un langage symbolique en programmation implique toujours les opérations sui-vantes : 1. écriture d'un programme au moyen d'instructions en langage clair, ce programme portant le nom

de programme source 2. traduction de ce programme en langage machine compréhensible par l'ordinateur, mais pas par le

programmeur 3. Liaison des divers modules programmés et des éléments de la librairie du langage et du système

d'exploitation afin de rendre l'ensemble exécutable dans l'environnement de l'ordinateur. C'était il y a plus de 30 ans que la maison IBM lançait une description préliminaire du langage de programmation FORTRAN :

FORTRAN ----> FORmula - TRANslator Le but de ce langage est de pouvoir programmer facilement les expressions littérales intervenant dans la résolution des problèmes mathématiques et scientifiques par des instructions du langage. Le nom FORTRAN désigne aussi bien le langage et sa syntaxe que le compilateur FORTRAN. En 1958 naissait une version améliorée FORTRAN II, introduisant la notion de sous-programme. En 1962 apparaît la version FORTRAN IV qui va durer pendant 16 ans, avec quelques améliorations et exten-sions apportées par les fabricants. L'essor pris par le langage PASCAL fait naître une nouvelle version améliorée de ce langage désignée par FORTRAN 77. Le langage FORTRAN 77 fait l'objet d'une normalisation de l'American National Standard : FORTRAN 77 (ANSI X3.9-1978). Les renseignements proposés dans ce cours sont un résumé des principales possibilités de ce langage et une description des particularités citées dans les manuels suivants : DOMAIN FORTRAN Apollo Cumputer Inc. Langage Reference Sigle utilisé ici : DOMAIN Microsoft FORTRAN Microsoft Corporation Optimizing Compiler Sigle utilisé ici : MS-FORTRAN VAX-11 FORTRAN Digital Equipment Corp. Language Reference Manual Sigle utilisé ici : VAX-11 La première et la dernière versions citées sont opérationnelles sur des mini-ordinateurs, la se-conde version est implémentable sur des micro-ordinateurs. Chaque version comprend des com-pléments, hors norme, qui seront discutées dans le chapitre 7 de ce cours. Ce cours est accessible à tout utilisateur connaissant quelques bases de la programmation. Il est complété par 40 programmes exécutables afin de concrétiser la syntaxe citée dans le texte. Les ins-tructions décrites ci-après sont conformes à la norme ANSI X3.9-1978 avec le complément MIL -STD-1753. Il est tout à fait normal de se demander pour quelles raisons le langage FORTRAN doit faire l'objet d'une étude détaillée à la suite d'un cours de programmation sur le langage PASCAL . Donnons

- 1 -

- Langage de programmation : Fortran 77 -

brièvement une justification des avantages et citons également les inconvénients de cet outil de création de logiciel :

1. Avantages du langage FORTRAN : 1.1 modularité de la programmation par création de sous-programmes distincts : subroutine et func-

tion, compilés indépendamment les uns des autres. 1.2 efficacité des compilateurs existants optimisant la traduction du langage source en langage

machine. 1.3 librairie de base étendue à disposition du programmeur surtout dans les opérations arithmétiques

et bibliothèques extérieures riches en sous-programmes fiables et testés. 1.4 définition de plusieurs types arithmétiques : entiers, réels simple et double précision, complexes

simple et double précision, opérations et fonctions sur ces entités.

2. Inconvénients du langage FORTRAN : 2.1 traitement relativement pauvre des entités alphanumériques comme les opérations entre les

chaînes de caractères. 2.2 absence de types de base ou créés par le programmeur : énuméré, intervalle, ensembles,

enregistrement, pointeurs, etc. 2.3 recours à une programmation non structurée par de nombreux sauts à l'intérieur du programme

source, d'où risques importants de difficultés de trouver les erreurs. Disons immédiatement que l'un des buts principaux de ce cours est de montrer non seulement comment utiliser les facilités du langage, mais également d'obtenir une programmation parfaitement structurée. Les programmeurs chevronnés de FORTRAN et PASCAL retrouveront la philosophie de ce dernier langage dans la présentation des instructions de base. Les conventions utilisées dans ce cours sont : 1. Les mots-clés de la syntaxe du langage FORTRAN sont écrits en minuscules et caractères gras. 2. Les identificateurs des entités sont écrits en lettres minuscules, caractères italiques inclinés. 3. Dans les exemples de programme, les mots-clés et les identificateurs ne sont pas représentés en

caractères gras. Dans ces textes, les parties en caractères gras sont utilisées pour mettre en évidence l'emploi d'une instruction ou d'une syntaxe en cours d'étude.

4. Les crochets [ ] entourent des éléments optionnels. 5. Les points de suspension ... indiquent que l'élément les précédant peut être répété plusieurs fois. 6. Le texte de base est écrit en caractères Arial 10. 7. Les exemples sont écrits en caractères Courier New 10. 8. Les exemples graphiques sont applicables au traceur HP 7475 A. Les divers chapitres de ce document traitent successivement les bases et les applications du langage surtout dans les problèmes de mathématique usuelle. Chapitre 1 L'introduction au langage FORTRAN donne un aperçu sur les composantes de base d'un pro-gramme, la description des caractères utilisables, l'écriture des instructions dans les 80 colonnes de la carte, la configuration d'un programme, finalement une liste des types et instructions. Chapitre 2 La présentation de tous les types de base du langage, avec les implémentations particulières, les domaines de définition, la représentation interne des données, c'est-à-dire dans la mémoire de l'ordi-nateur, commence le second chapitre. Les constantes, les variables simples et de tableaux sont discutées ensuite avant de passer à l'étude des expressions arithmétiques, chaînes de caractères,

- 2 -


relationnelles et logiques. Dans une première étude du langage, les variantes des types fonda-mentaux peuvent être laissées de côté et reprises dans une vue complète des possibilités de FORTRAN Chapitre 3 Les instructions de base sont classées en trois catégories : - instructions utilisées dans les structures séquentielles, - structures sélectives avec citation de toutes les possibilités de choix inconditionnel ou conditionnel, - structures itératives ou à répétition. Chapitre 4 La structuration d'un programme fait intervenir obligatoirement des sous-programmes dédiés à une tâche allant de l'élémentaire à la forme la plus complexe. La richesse de la librairie du langage permet de résoudre de nombreux problèmes mathématiques et des tableaux donnent la liste des fonctions à disposition. Le programmeur dispose de trois genres de sous-programmes afin de faciliter les accès aux tâches à résoudre. Quelques instructions permettent de gérer au mieux la place dispo-nible en mémoire. Chapitre 5 La mise en forme agréable des données est une propriété de FORTRAN . L'énumération des divers descripteurs à disposition, les possibilités de lecture et d'écriture terminent ce chapitre im-portant dans la pratique courante. Chapitre 6 Si les données deviennent volumineuses et si des textes ou des tableaux doivent pouvoir se lire pendant l'exécution d'un programme, l'emploi de fichiers devient absolument nécessaire. Le chapitre présente les divers types de fichier, les modes d'accès et les nombreuses clauses facilitant grande-ment la manipulation des données numériques et alphanumériques. Chapitre 7 Ce dernier chapitre décrit la programmation des instructions permettant d'accéder aux routines graphiques du traceur HP 7475 A . Les instructions du langage HP-GL sont citées et plusieurs pro-grammes montrent l'utilisation de cette syntaxe dans le langage FORTRAN. Les implémentations des trois systèmes sont décrites en fin de chapitre. Annexes et exemples Les 40 exemples de ce cours peuvent faire l'objet d'un document enregistré sur un CD que l’utilisateur pourrait directement employer, soit : - 40 exemples, système d'exploitation MS-DOS sur micro-ordinateurs IBM et compatibles, - 40 exemples, système d'exploitation AEGIS sur station Apollo, - 40 exemples, système d'exploitation VMS sur Micro-VAX. Le dernier exemple n'est exploitable que sur une station Apollo, car il utilise des routines graphiques spécifiques à ce système d'exploitation.

- 3 -


BIBLIOGRAPHIE Adobe Systems PostScript par l’exemple (original en anglais) Outil pour l’édition électronique Texte français d’Alain Kadé, InterEditons 1987 Lignelet P. FORTRAN 77, Le langage Fortran Masson, Paris 1984 Lignelet P. Les fichiers en FORTRAN 77 avec exercices résolus, Masson, Paris 1988 MacCracken D. Computing for Engineers and Scientists with Fortran 77 John Wiley & Sons, Inc, 1984 Edition allemande : Computer Praxis mit Fortran 77 Hanser Verlag München 1985 Press H. William Numerical Recipes Flannery Brian P. The Art of Scientific Computing Teukolsky Saul A. (Fortran Version) Vetterling William T. Cambridge University Press 1990 Strohmeier A. FORTRAN 77 , Approche systématique illustrée d'exemples Eyrolles, Paris 1984 Les sources bibliographiques des trois implémentations citées et traitées dans ce cours sont données au chapitre 7 . La description du traceur HP 7475 A , des instructions du langage graphique HP-GL et de l'interfaçage avec les micro-ordinateurs, est donnée dans : Hewlett Packard Manuel d'interface et de programmation Traceur graphique HP 7475 A Document 07475-90026, June 1984

- 4 -

CHAPITRE 1

INTRODUCTION À FORTRAN-77

Un programme source FORTRAN se compose d'une suite d'instructions successives et option-nellement de commentaires. Les diverses instructions sont groupées en unités logiques appelées unités de programme. Chaque unité de programme comprend une séquence d'instructions terminée obligatoirement par l'instruction end . Une unité de programme définit une procédure de manipulation de données et peut être : 1. Un programme proprement dit, appelé programme principal (en anglais informatique désigné par

main) et commençant optionnellement par l'instruction program. 2. Un sous-programme : - subroutine sous-programme général FORTRAN, - function : sous-programme fonction retournant une valeur, - block data : sous-programme particulier d'initialisation. Un programme exécutable, après traduction et assemblage, se compose d'au moins d'un pro-gramme principal et d'un ou de plusieurs sous-programmes. La technique de structuration des actions à effectuer par le programme complet fait un emploi très étendu des procédures et fonctions. Toutes les instructions d'un programme FORTRAN peuvent se grouper en deux catégories bien distinctes : 1. Les instructions exécutables qui décrivent l'action du programme sur les diverses entités uti-

lisées. 2. Les instructions non-exécutables qui décrivent l'arrangement des données et leurs caractéris-

tiques, qui fixent les conditions d'édition de textes et de valeurs numériques ou littérales en lecture ou écriture, qui effectuent les conversions des valeurs à gérer dans le programme.

Les instructions sont divisées en secteurs physiques appelés lignes contenant jusqu'à 80 carac-tères, héritage de l'emploi des cartes perforées au début de l’ère infiormatique. Si une instruction est plus longue, elle peut être continuée sur une seconde ligne ou sur plusieurs lignes, jusqu'à 19 lignes de suite. Chaque instruction doit s'écrire sur une nouvelle ligne. Exemple élémentaire : Programme élémentaire montrant la façon d'introduire un nombre entier et d'afficher le quadruple de ce nombre. * * Exemple 1 * Programme élémentaire lisant un nombre * et calculant son quadruple program exemOl integer*4 i,j * print *,'Entrez un nombre entier :' read *,i j=4*i print *,'Valeur introduite : ',i,' , quadruple = ',j end

- 5 -


Résultat de l'exécution du programme : Entrez un nombre entier 123 Valeur introduite : 123 , quadruple = 492 Cet exemple comprend les quatre parties fondamentales que l'on rencontre pratiquement dans tous les programmes : 1. déclaration des entités utilisées, 2. introduction des données numériques, 3. traitement des données, 4. affichage des résultats. 1.1 CARACTÈRES ET INSTRUCTIONS Le langage FORTRAN ne connaît pas de mots réservés comme la plupart des autres langages de programmation et ne fait pas de distinction entre les lettres majuscules et minuscules dans l'écriture des mots de la syntaxe et les identificateurs d'entités. La plupart des anciens programmes sont écrits en lettres majuscules, ce qui n'est plus une obligation avec la version FORTRAN-77. 1.1.1 CARACTÈRES DU LANGAGE Les caractères utilisables dans la syntaxe et les identificateurs des instruction du langage appar-tiennent au code ASCII à 7 bits (ASCII > American Standard Code for Information Interchange), les lettres accentuées n'étant pas autorisées dans ce cas. Les caractères utilisables sont limités à : 1. Toutes les 26 lettres majuscules de A à Z ainsi que toutes les 26 lettres minuscules de a à z . 2. Tous les chiffres de 0 à 9. 3. Les caractères spéciaux suivants espace = signe d'égalité + plus - moins * astérisque / barre oblique (slash) ( parenthèse gauche , virgule ) parenthèse droite . point ‘ apostrophe ״ guillemet $ dollar ! point d'exclamation : double point _ barre de soulignement En extension des caractères de base : < signe plus petit que % pourcent > signe plus grand que & et commercial { accolade gauche } accolade droite Les autres caractères ASCII , des codes à 7 et 8 bits, ne peuvent apparaître que comme cons-tante Hollerith ou dans une chaîne de caractères. Lors de la traduction du programme source, le compilateur FORTRAN ne fait aucune distinction entre les majuscules et les minuscules, sauf dans les chaînes de caractères à afficher et à imprimer. Le compilateur ne tient pas compte des espaces.

- 6 -

- 1. Introduction à Fortran 77 -

1.1.2 CHAMP POUR INSTRUCTIONS La configuration de l'écriture d'une instruction FORTRAN a conservé le style valable au moment de l'introduction du langage, soit la carte perforée à 80 colonnes. Les instructions ne portent aucun repère de ligne, à moins d'ajouter un repère numérique ou alphanumérique dans la dernière zone de la ligne. Sur la carte perforée FORTRAN, plus guère utilisée actuellement, et à l'édition du programme source, quatre zones sont à disposition pour l'écriture des instructions : 1. une zone d'étiquettes et d'introduction de commentaires, colonnes 1 à 5; 2. une zone de suite, colonne 6; 3. une zone réservée à l'écriture proprement dite des instructions, colonnes 7 à 72; 4. une zone d'identification, colonnes 73 à 80. CARTE FORTRAN À 80 COLONNES

Les colonnes réservées sont les suivantes : 1. La colonne 1 est réservée au caractère C (ou c), à l'astérisque * , pour l'identification d'un

commentaire. Chaque ligne de commentaire doit contenir dans sa première colonne un C (ou c) ou un * . Les commentaires peuvent s'écrire dans les colonnes 2 à 72. Dans ce cours, nous utiliserons le caractère * . Variante DOMAIN et VAX-11 : la première colonne peut contenir le caractère D (ou d) permettant une compilation conditionnelle d'une instruction.

2. Les cinq premières colonnes sont réservées à l'écriture des diverses étiquettes : valeur entière non signée de 1 à 99999, unique dans l'unité de programme et ne comprenant que des chiffres et/ou des espaces.

3. La colonne 6 est réservée au caractère d'identification d'une ligne de suite ou additionnelle : tout caractère ou tout chiffre, sauf zéro ou l'espace peuvent s'utiliser dans ce but. Dans les exemples, nous utiliserons soit le caractère c , soit le caractère + .

4. Les colonnes 7 à 72 sont réservées à l'écriture des instructions du programme. Actuellement, les programmes sont écrits au moyen d'un éditeur de texte. Si cet éditeur n'affiche pas le numéro de colonne où se trouve la pointeur d'écriture, introduisez 6 espaces avant de commencer à écrire l'instruction FORTRAN , le pointeur se trouvant dans la colonne 7. La colonne 72 est très souvent signalée par la marge de droite ou par un signal acoustique. Evitez d'utiliser le tabulateur pour positionner les instructions, ce caractère n'étant pas reconnu par tous les compilateurs.

5. Les colonnes 73 à 80 sont réservées aux identificateurs de rangement des instructions sur cartes perforées, les lignes du programme n'étant pas numérotées.

Particularités Dans la plupart des implémentations FORTRAN , un commentaire complémentaire peut se placer à la suite d'une instruction, dans n'importe quelle colonne entre 2 et 72, ce commentaire étant signalé par le caractère ! . Le caractère espace, dit également blanc, n'a pas de signification pour le compilateur et s'utilise seulement pour améliorer la lisibilité du programme. Les exceptions à cette règle sont : 1. les blancs sont significatifs dans les chaînes de caractères; 2. les blancs sont significatifs dans les constantes Hollerith; 3. un blanc dans la colonne 6 signifie une nouvelle instruction et non une ligne de suite.

- 7 -


De ces diverses règles contraignantes, nous nous apercevons que le numéro de colonne est significatif dans l'écriture des instructions du fichier source. Un programme source FORTRAN est donc une séquence de lignes dans laquelle seuls les 72 premiers caractères sont retenus par le compilateur. Les caractères après le 72ième sont ignorés ! 1.2 CONFIGURATION D'UN PROGRAMME Une instruction FORTRAN consiste en une ligne initiale suivie de zéro à dix-neuf lignes de suite. Cette instruction peut contenir jusqu'à 1320 caractères dans les colonnes 7 à 72. L'instruction end doit être la dernière instruction de l'unité de programme, placée sur une ligne d'instruction. Pendant la compilation, chaque unité de programme est traduite en langage machine par le com-pilateur, indépendamment des autres unités de programme. Il en résulte que les unités de programme peuvent se trouver : 1. dans un fichier texte contenant le programme complet soit le programme principal et tous les

sous-programmes. 2. dans plusieurs fichiers texte contenant chacun une ou plusieurs unités de programme, ce grou-

pement étant laissé au choix du programmeur. 3. Le nom du fichier, conforme à la syntaxe du système d'exploitation, avec une extension signalant

la présence d'un texte en langage source FORTRAN , peut porter un identificateur différent de l'identificateur de l'unité de programme.

Tableau 1.1 ORGANISATION DES INSTRUCTIONS DANS UNE UNITÈ DE PROGRAMME

Directives générales de compilation : ne font pas partie de FORTRAN et dépendent de l'implémentation du langage dans le système d'exploitation de l'ordinateur

Instruction de définition de l'unité de programme

program , function , subroutine ou block data Instruction implicit

Instructions de spécification

Instructions : Functions- formules

lignes de commentaires première olon e c nC ou c ou *

instructions format et

entry

Instructions executables

instruction data

instruction end

- 8 -


1.2.1 HIÉRARCHIE DES INSTRUCTIONS Les instructions du programme doivent se donner dans un ordre logique, le compilateur ne pou-vant pas deviner la nature d'entités non reconnues. Le tableau 1.1 ci-dessus montre la disposition générale d'un programme source avant compilation. Elle indique également la priorité des instructions de spécification les unes par rapport aux autres. Les instructions exécutables comprennent toutes les instructions du langage FORTRAN. Les directives générales de compilation permettent de choisir certaines définitions particulières du compilateur. La forme de ces instructions ne fait pas partie du langage FORTRAN et dépend donc de l'implémentation dans le système d'exploitation de l'ordinateur. L'organisation proposée est à lire de haut en bas. 1.2.2 INSTRUCTIONS DE SPÉCIFICATION Les instructions de spécification fixent les caractéristiques des données numériques et alpha-numériques à stocker en mémoire et à manipuler dans le programme. La mémoire est organisée en paire d'octets, chaque octet contenant 8 bits. Dans les ordinateurs à processeur à 32 bits, quatre octets forment un long mot. Le tableau 1.2 donne les types existants : entier, réel, complexe, double précision, logique ou booléen, chaîne de caractères. Le nombre figurant après le type fixe le nombre d'octets occupé en mémoire par les constantes ou variables de ce type . Le tableau 1.3 énumère les instructions de spécification.

Tableau 1.2

TYPES DE DONNÉES DANS LE LANGAGE FORTRAN Types numériques Types non numériques integer (entier) integer*2 integer*4 real (réel) real*4 real*8 double precision complex (complexe) complex*8 complex*16 (hors norme)

logical (logique) logical*2 logical*4 character

Le sufffixe *4 signifie une occupation de quatre octets en mémoire et *2 une occupation de deux octets.

Tableau 1.3

INSTRUCTIONS DE SPÉCIFICATION Instructions de spécification Instructions de communication

Tous les types cités ci-dessus dimension external implicit intrinsic parameter

equivalence common

save

- 9 -


1.2.3 INSTRUCTIONS EXÉCUTABLES Les instructions exécutables permettent de créer les structures usuelles de programmation sé-quentielles, sélectives et itératives. Elles sont données par ordre alphabétique dans le tableau 1.4 ci-après.

Tableau 1.4

INSTRUCTIONS EXECUTABLES DE FORTRAN assign else if then open instructions else pause d'affectation encode (*) print backspace end read call end do return close end if rewind continue end file stop decode (*) go to write do if do while inquire

(*) Instruction FORTRAN IV pour compatibilité de programmes

L'instruction format peut apparaître à tout endroit dans l'unité de programme après l'en-tête et avant l'instruction terminale end . 1.2.4 UNITÉS DE PROGRAMME Un sous-programme commence par une instruction : subroutine ,function ou block data et se termine par une instruction end . Un programme principal commence par l'instruction program, cette instruction étant optionnelle, ou toute autre instruction sauf subroutine , function ou block data . Ces unités se distinguent encore par leurs identificateurs ou noms symboliques, ces identificateurs étant globaux c'est-à-dire uniques dans l'ensemble du programme. 1.2.4.1 IDENTIFICATEURS Les identificateurs ou noms symboliques sont employés en programmation FORTRAN pour dis-tinguer les diverses entités telles que : unités de programme, variables simples et variables de ta-bleaux, arguments et paramètres de liste, etc. L'identificateur est une suite de caractères, seulement des lettres ou des chiffres, dont le premier caractère doit être absolument une lettre. Le nombre de caractères est limité à 6 selon norme ANSI . Les fournisseurs de compilateurs ont étendu cette défi-nition restrictive afin d'améliorer la lisibilité des programmes. Dans toutes les extensions, le premier caractère doit rester une lettre. DOMAIN L'identificateur peut comprendre jusqu'à 32 caractères significatifs, lettres et chiffres, et en plus les deux caractères : dollar $ et le caractère de soulignement _ . MS-FORTRAN Seuls les six premiers caractères, lettres ou chiffres, sont significatifs, les caractères suivants étant ignorés par le compilateur.

- 10 -


VAX-11 L'identificateur peut comprendre jusqu'à 31 caractères, lettres ou chiffres, le caractère $ et le caractère de soulignemenrt _ étant autorisé. Le caractère $ ne peut s'introduire que dans les composantes DEC . Il n'y a pas de confusion possible entre les mots de la syntaxe FORTRAN et les identificateurs adoptés par le programmeur. Le compilateur est capable de distinguer ces entités en se servant du contexte des instructions. Il est quand même recommandé de ne pas utiliser les mots du langage comme identificateur des autres entités. Les identificateurs du langage source sont des interfaces avec des places mémoires utilisées dans l'ordinateur. Exemples d'identificateurs : - selon norme ANSI : antony nombre aligne ibarre

- en extension de la norme : antoine_dupont nombre—de—mots ibarre—de—travers

Les identificateurs de variables doivent rester uniques dans chaque unité de programme et ne peuvent donc pas s'employer pour deux ou plusieurs entités différentes. 1.2.4.2 PROGRAMME PRINCIPAL Le programme principal peut débuter par l'instruction optionnelle program et se composer d'une suite de commentaires, d'instructions de spécification et d'instructions exécutables. Il ne doit pas con-tenir d'instructions : subroutine , function ou block data. La syntaxe de la déclaration du programme est program identif avec : identif l'identificateur donné à l'unité de programme principal. Le programme principal se termine par l'instruction end . En l'absence de l'instruction initiale program ... , le compilateur introduit habituellement un identificateur d'unité par défaut, le plus souvent main . 1.2.4.3 SOUS-PROGRAMMES Un sous-programme peut se composer d'une suite de commentaires, d'instructions de spécifi-cation et d'instructions exécutables. Il débute toujours par l'une des instructions subroutine function block data Le sous-programme classique, effectuant une tâche multiple, commence par l'instruction subroutine et contient des instructions exécutables. Pour trouver une seule valeur à partir d'une définition extérieure à l'unité de programme, le programmeur utilise une fonction faisant partie soit de la librairie du langage, soit écrite spécialement pour l'application. Tous les sous-programmes se terminent par l'instruction end indiquant au compilateur la fin de la traduction de l'unité de programme.

- 11 -

CHAPITRE 2

EXPRESSIONS FORTRAN Les expressions du langage FORTRAN se composent d'opérandes et d'opérateurs obéissant à des règles strictes de syntaxe. Les composantes principales des expressions sont : 1. des constantes

Une constante est une donnée numérique, logique ou alphanumérique qui reste invariable tout au long de l'exécution d'un programme.

2. des variables simples Une variable simple est représentée par un identificateur associé à une place mémoire dont la valeur est le contenu de cette place mémoire. Cette donnée peut être modifiée en cours d'exécution par les instructions du programme.

3. des variables de tableau Une variable de tableau ou variable indicée représente un groupe de places contiguës en mémoire associé à un seul identificateur. Chaque élément du tableau est référencé par l'identificateur de la variable et par un ou plusieurs indices.

4. des références à une fonction Une fonction calcule ou transforme une ou plusieurs données, à partir d'un ou plusieurs arguments, donnant un seul résultat, au moyen d'une unité de programme et renvoie ce résultat dans l'instruction d'appel.

5. des opérateurs Le langage FORTRAN distingue les opérateurs : arithmétiques, relationnels et logiques intervenant entre les opérandes dans des expressions numériques, alphanumériques et logiques. 6. des expressions

Une expression FORTRAN se compose d'un ou de plusieurs opérandes (constantes, variables, éléments de tableau, fonctions) reliés par des opérateurs appropriés. Il existe quatre genres d'expressions :

6.1. les expressions arithmétiques, 6.2. les expressions alphanumériques, 6.3. les expressions relationnelles, 6.4. les expressions logiques. Chaque catégorie d'expression utilise certains types d'opérandes et emploie un ensemble bien déterminé d'opérateurs.

2.1 TYPES DE DONNÉES Le langage FORTRAN reconnaît six types de base des données : 1. type entier : integer (integer*2 et integer*4), 2. type réel simple précision real (ou real*4), 3. type réel double précision double precision (ou real*8), 4. type logique : logical (logical*2 ou logical*4), 5. type complexe : complex (complex*8 ou complex*16), 6. type caractère : character . Le type attribué à une donnée caractérise la place occupée par cette donnée en mémoire et la manière dont cette donnée est stockée au moyen d'octets et de bits. Toutes les données sont

- 12 -

- 2.Expressions du langage Fortran 77 -

enregistrées sous forme de bits, valant 0 ou 1 , organisés par groupe de 8 bits pour former un octet et finalement en long mot de 4 octets dans les processeurs à 32 bits. Tout enregistrement d'une donnée numérique ou alphanumérique nécessite la traduction de cette donnée, introduite par exemple par une frappe au clavier et apparaissant à l'écran, en une suite de bits. La lecture d'une donnée stockée en mémoire s'effectue par l'opération inverse. A chaque traitement e des données, il ne faut pas perdre de vue : 1. la représentation externe de la donnée de telle sorte qu'elle soit compréhensible pour l'utilisateur

du programme. Exemple :

- donnée numérique : -3143.6543

- donnée alphanumérique : programmation

2. la représentation interne de la donnée qui peut dépendre du fabricant du compilateur ou d'une normalisation de la transformation. Dans la plupart des applications, le programmeur n'a pas à étudier cette représentation sous forme de bits, mais doit conserver cette notion importante de transformation en évitant toute opération inutile dans le déroulement du programme.

2.1.1 OCCUPATION EN MÉMOIRE DES DIFFÉRENTS TYPES L'occupation en mémoire des divers types existants du langage, pour les trois compilateurs discutés dans ce cours, est donnée dans le tableau 2.1 .

Tableau 2.1

OCCUPATION EN MEMOIRE DES TYPES FORTRAN

Occupation exprimée en octets Type de données

DOMAIN FORTRAN

Micosoft MS-FORTRAN

DEC FORTRAN

Integer 1) integer*2 integer*4

real real*4

double precison real*8 real*16

complex complex*8 complex*16

logical logical*2 logicial*4

character character*len character*(*)

2 ou 4 2 4

4 4

8 8 -

8 8 -

2 ou 4 2 4

len (libre)

2 ou 4 2 4

4 4

8 8 -

8 8 16

2 ou 4 2 4

len (libre)

2 ou 4 2 4

4 4

8 8 16

8 8 16

2 ou 4 2 4

len (libre)

1) Par défaut : 4 octets 2 octets avec directive de compilation

- 13 -


VAX-11 reconnaît également le type byte occupant un octet en mémoire et permettant de représenter des entiers compris entre -128 et 127, de même qu'un type booléen logical*1 sur un octet. Le type character*(*) s'applique seulement aux paramètres formels des sous-programmes ou aux fonctions de type character. 2.1.2 TYPE ENTIER : INTEGER Le type entier, en programmation integer , est un sous-ensemble de l'ensemble des nombres entiers. Ces nombres entiers ont une représentation exacte dans le domaine de définition. Le langage FORTRAN reconnaît les types integer suivants :

integer Ce type occupe quatre octets en mémoire et représente les entiers, en mémoire dans le système binaires, dans le domaine de définition compris entre : -2 147 483 648 et +2 147 483 647 soit -231 et +231-1. La représentation interne d'un entier de type integer, dans 4 octets contigus, est :

31 0 b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b

Octet 0 Octet 1 Octet 2 Octet 3

integer*4 Ce type est identique au type fondamental integer, avec les mêmes propriétés et possibilités de représentation des entiers.

integer*2 Ce type occupe deux octets en mémoire et représente les entiers, en mémoire dans le système binaire, dans le domaine compris entre : -32 768 et +32 767 soit de -215 à +215-1 La représentation interne d'un entier integer*2 , dans 2 octets contigus, est : 15 0 b b b b b b b b b b b b b b b b

Octet 0 Octet 1

2.1.3 TYPE RÉEL : REAL Les données de type réel, en programmation real , font partie d'un sous-ensemble de l'ensemble des nombres réels. Une donnée réelle est enregistrée habituellement par une représentation approximative du nombre réel désiré et occupe quatre octets en mémoire.

real Ce type occupe 4 octets en mémoire et représente une donnée réelle au moyen de trois compo-santes : le signe, l'exposant et la mantisse. Les nombres réels peuvent se définir entre :

- 14 -


- valeurs positives de 8.43.10-47 à 3.37.10+38

- valeurs négatives de -3.37.10+38 à -8.43.10-47

- valeur nulle : 0 - nombre de chiffres significatifs : plus grand que 6, inférieur à 7. La représentation interne d'une donnée de type real suit la norme IEEE dans la plupart des compilateurs. Le bit 31 est le bit de signe : il est égal à 1 si le nombre est négatif, égal à 0 si le nombre est positif. Les huit bits suivants contiennent l'exposant plus 127 (sous forme binaire). Les 23 autres bits contiennent la mantisse.

31 30 22 16 0 b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b

s exposant+127 Mantisse

real*4 Autre désignation pour le type real , d'où mêmes caractéristiques. 2.1.4 TYPE : DOUBLE PRECISION Les données de type double precision font partie d'un sous-ensemble des nombres réels. Une donnée de type double precision est enregistrée habituellement par une représentation appro-ximative du nombre réel désiré et occupe huit octets en mémoire.

double precision Ce type occupe 8 octets en mémoire et représente une donnée réelle au moyen de trois com-posantes : le signe, l'exposant et la mantisse. Les données réelles peuvent se représenter dans les domaines :

- valeurs positives 4.19E-307 à 1.67E+308 - valeurs négatives -1.67E+308 à -4.19E-307 - valeur nulle : 0 - nombre de chiffres significatifs : plus grand que 15. La représentation interne d'une donnée de type double precision , selon norme IEEE, est implé-mentée dans la plupart des compilateurs sous la forme suivante :

63 62 51 32 b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b

s exposant+1023 mantisse

Bits : de 31 à 0 : mantisse

Le bit 63 est le bit de signe qui vaut 1 si la donnée est négative, qui vaut 0 si la donnée est positive. Les 11 bits suivants contiennent l'exposant plus 1023 (sous forme binaire). Les 52 bits restants représentent la mantisse.

real*8 Autre désignation pour double precision , d'où mêmes caractéristiques. Particularités VAX-11 double precision ou real*8 : en mode normal D : 16 chiffres significatifs dans la gamme des modules compris entre 0.29D-38 et 1.7D+38. En mode G avec la directive de compilation /G–FLOATING, la représentation se réalise selon la norme IEEE.

- 15 -


real*16 représentation des nombres réels jusqu'à 33 chiffres significatifs dans la gamme des modules 0.84Q-4932 et 0.59Q+4932. Ce type ne peut s'introduire que sur VAX-11 avec processeur arith-métique à virgule flottante étendue. 2.1.5 TYPE COMPLEXE : COMPLEX Les données de type complex se compose de deux nombres réels en simple précision, le premier nombre est la partie réelle, le second nombre est la partie imaginaire du nombre complexe. Une donnée complexe occupe huit octets contigus en mémoire. La représentation interne selon la norme IEEE est : 63 62 54 32 b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b

s Exposant+127 Mantisse (partie réelle)

s Exposant+127 Mantisse (partie imaginaire)

Les possibilités de représentation de la partie réelle et de la partie imaginaire du nombre com-plexe correspondent exactement à celles des données de type real ou real*4 .

complex*8 Ce type est une autre désignation pour le type complex , d'où mêmes caractéristiques.

complex*16 Ce type représente une donnée complexe au moyen de deux nombres de type double precision. Il utilise 16 octets de mémoire. Le premier nombre est placé dans la partie réelle, le second dans la partie imaginaire. Les limites de la représentation numérique sont identiques à celles des types double precision. Ce type est hors norme ANSI. 2.1.6 TYPE BOOLÉEN OU LOGIQUE : LOGICAL Le type booléen ou logique, dans le langage FORTRAN s’écrit logical , comprend seulement deux valeurs : .true. et .false . Une donnée booléenne occupe normalement quatre octets en mémoire à moins qu'une directive de compilation en fixe la taille à deux octets. La représentation interne d'une donnée de type logical sur 4 octets est la suivante : 31 0 b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b

Octet 0 Octet 1 Octet 2 Octet 3

Le bit 31 est mis à 1 si la valeur est vraie (= .true) et à 0 si la valeur est fausse (= .faIse). Tous les autres bits sont normalement non définis.

logical*4 Ce type est identique à logical sur 4 octets, d'où mêmes caractéristiques.

logical*2 Ce type utilise 2 octets en mémoire, le bit 15 indiquant si la valeur est vraie ou fausse.

- 16 -


2.1.7 TYPE CARACTÊRE : CHARACTER La donnée de type caractère, dans le langage FORTRAN character , est une séquence de caractères ordonnée selon le code ASCII . La longueur de la donnée est égale au nombre de carac-tères contenu dans la chaîne de caractères. Le nombre maximal de caractères que peut contenir la chaîne dépend de l'implémentation du compilateur : DOMAIN : 1 à 32768 caractères, MS-FORTRAN : 1 à 32767 caractères, VAX-11 : 1 à 45535 caractères. Chaque caractère occupe un octet en mémoire, le code ASCII du caractère étant enregistré sous forme binaire. Les caractères sont stockés dans des places mémoires contiguës. Si une donnée numérique suit une chaîne de caractères, cette donnée commence à la limite d'un mot, mot pouvant comprendre deux ou quatre octets, donc dans tous les cas un nombre pair d'octets.

2.2 CONSTANTES FORTRAN Une constante est une donnée numérique, alphanumérique ou logique, donc caractérisée par un type, qui ne change pas en cours de programme. 2.2.1 CONSTANTES ENTIÈRES Une constante entière décimale s'écrit au moyen de 1 à n chiffres et représente une donnée de type integer . Elle est affectée d'un signe si elle suit immédiatement un caractère + ou - Sans signe, la constante est positive. La syntaxe générale est :

snn avec : s le signe de la constante, le signe + étant optionnel, nn une suite de chiffres de 0 à 9. Une constante entière ne peut pas contenir de signes spéciaux, en particulier ni virgule, ni point. Les limites numériques de la représentation d'une constante entière sont :

type integer*4 -231 à +231-1

type integer*2 -215 à +215-1

Exemples :

type integer*2 ou integer*4 -1234 23678

seulement type integer*4 : 12345678 2.2.2 CONSTANTES RÉELLES Une constante réelle en simple précision se caractérise par une suite de chiffres avec un point décimal. En FORTRAN , il est possible d'écrire une constante réelle sous deux formes numériques différentes : forme usuelle avec le point décimal à la place de la virgule et forme avec exposant de dix. Les syntaxes complètes se composent : - d'un signe, optionnel pour les constantes positives, - d'une partie entière, - du point décimal, - d'une partie fractionnaire, - d'une partie exposant.

- 17 -


snn.nn snn.nnEsnn avec : nn une suite de chiffres de 0 à 9, s le signe + ou -, optionnel si la constante ou l'exposant sont positifs, E le symbole pour la puissance de 10, la lettre E, suivi du signe ou d'une constante entière à 1 ou 2

chiffres représentant l'exposant de 10. La partie entière et la partie fractionnaire comporte un ou plusieurs chiffres et le point décimal. L'une des parties doit être au moins présente dans l'écriture de la constante. La partie exposant se compose de la lettre E , signifiant 10 à la puissance, suivie d'un signe, optionnel si l'exposant est positif, d'une constante de un ou de deux chiffres. Le nombre de chiffres n'est pas limité dans la suite, mais seuls les 6 à 7 chiffres significatifs les plus à gauche sont retenus dans la représentation interne de la constante. Il faut se souvenir que l'introduction au clavier d'une constante réelle s'effectue par les opérations suivantes : - écriture d'une chaîne de caractères selon la syntaxe proposée, - transformation de cette chaîne en valeur numérique de type real et trois composantes : signe, exposant et mantisse. La transformation s'effectue presque toujours avec une modification de la valeur initiale de la constante, en particulier avec les valeurs décimales. Exemples :

123.456 12.3456E1 1.23456E+01

-0.09876 -.9876E-1 -9.876E-02

Dans l'écriture d'un programme, il est vivement recommandé d'écrire le zéro devant le point décimal et le zéro derrière le point décimal à la place du point décimal seul. La lecture des valeurs numériques à l'écran et surtout sur le papier est fortement facilitée. 2.2.3 CONSTANTES EN DOUBLE PRÉCISION Une constante en double précision est une constante réelle suivie toujours d'un exposant décimal, écrite sous la forme générale suivante :

snnDsnn snn.nnDsnn avec : nn une suite de chiffres de 0 à 9, s le signe + ou -, optionnel si la constante ou l'exposant sont positifs, D le symbole de la puissance de 10 et de la constante en double précision, suivi du signe et d'une

constante entière de 1, 2 ou 3 chiffres représentant l'exposant de 10. L'exposant après la lettre D ainsi que la lettre D ne peuvent pas être oubliés, même si l'exposant vaut zéro.

Exemples :

1.234567891D+10 -234.567890123D-124 0.0156D0

Particularités VAX-11 : voir description des types et symboles G et Q sous 2.1.4. 2.2.4 CONSTANTES COMPLEXES Une constante complexe est une paire de constantes réelles, séparées par une virgule, placée entre parenthèses. La première constante réelle représente la partie réelle du nombre complexe, la seconde la partie imaginaire.

- 18 -


(snn.nn,snn.nn) (snn.nnEsnn,snn.nnEsnn) (snn.nnDsnn,snn.nnDsnn) avec : nn une suite de chiffres de 0 à 9, s le signe + ou -, optionnel si la constante réelle ou l'exposant sont positifs, E le symbole pour la puissance de 10, suivi du signe et d'une constante entière à 1 ou 2 chiffres

représentant l'exposant de 10 . Cette syntaxe est applicable aux constantes de type complex ou complex*8.

D le symbole pour la puissance de 10, suivi du signe et d'une constante entière de 1, 2 ou 3 chiffres représentant l'exposant de 10. Cette syntaxe n'est applicable qu'aux constantes complexes de type complex*16 (hors norme ANSI).

Exemples :

(1.7864,-23.7652) (12.34E+15,-23.789E-6) (-1.0,+1.0) (2.3456789O1D4,9.87654321098D-3) 2.2.5 CONSTANTES ENTIÈRES NON DÉCIMALES La plupart des compilateurs acceptent des constantes entières exprimées dans une base différentes de la base 10, habituellement des constantes hexadécimales (base 16) et des constantes octales (base 8). Cette représentation ne fait pas partie de la norme ANSI . 2.2.5.1 DOMAIN Les constantes octales et hexadécimales peuvent s'introduire chaque fois à la place d'une cons-tante décimale, sauf pour les étiquettes. L'écriture des constantes suit la syntaxe particulière : Constante octale Constante hexadécimale

8#cic2c3 ... cn 16#cic2c3 ... cn avec : ci un chiffre de 0 à 7 ci un chiffre de 0 à 9 une lettre de A à F ou de a à f Exemples :

8#123 8#6732 16#ab121 16#fffa 2.2.5.2 MS-FORTRAN Les constantes de bases différentes de 10 sont écrites au moyen d'une chaîne de caractères comprenant : le signe, optionnel si la constante est positive, la base, le caractère # , la chaîne pouvant comporter tous les chiffres de 0 à base-1 , les valeurs comprises entre 11 et 36 étant représentées par des lettres de A à Z . La syntaxe générale est :

sbb#cl c2c3..cn avec : s le signe, optionnel si la constante est positive, bb la base de numération, ci un caractère, chiffre ou lettre conforme à la base adoptée.

- 19 -


Exemples :

2#101010 8#6234 -16#12ABC 2.2.5.3 VAX-11 Constantes octales ‘c2c3...cn'O avec : ci un chiffre compris entre 0 et 7

Constantes hexadécimales : ‘cl c2c3 ... cn'X avec : ci un chiffre compris entre 0 et 9 ou une lettre comprise entre A et F ou a et f Exemples : correct incorrect

'06352'O '7890'O ‘11’O 3456'O 'ABC3'X 'BC9.3'X '12345'X 'F73X

Les constantes octales et hexadécimales n'ont pas de type numérique, le type dépendant du contexte dans lequel elles sont utilisées. 2.2.6 CONSTANTES LOGIQUES Une constante logique spécifie la valeur logique "vraie" ou "faux". Le langage FORTRAN distingue seulement deux constantes logiques :

.true. .false. Les points de part et d'autre de la constante logique font partie de l'écriture de chacune des constantes logiques. 2.2.7 CONSTANTES CHAINE DE CARACTÈRES Une constante de type chaîne de caractères, est une suite de caractères ASCII encadrée de deux apostrophes.

'c1 c2c3c4 ... cn' avec : ci un caractère ASCII, l'équivalent numérique étant compris entre 1 et 255. Le code ASCII est

compatible seulement sur les caractères 32 à 126, c'est-à-dire sur les lettres non accentuées. A l'intérieur de la chaîne de caractères, le caractère apostrophe doit se représenter par deux apostrophes, sans espace ou autre caractère. La longueur de la constante est égale au nombre de caractères entre les deux apostrophes d'encadrement. Chaque caractère occupe un octet en mémoire. Exemples :

'Introduisez la prochaine valeur ' 'l''espoir n''est pas pour demain' 'Frappez un "1" ou un "0" comme reponse'

- 20 -


2.2.8 CONSTANTES HOLLERITH La constante Hollerith est une relique des premières versions de FORTRAN et de la carte perforée. C'est une chaîne de caractères ASCII précédée d'un compteur de caractères et de la lettre H (majuscule). La constante Hollerith ne fait plus partie de FORTRAN-77 , mais pratiquement tous les compilateurs admettent cette constante (voir également le spécificateur H). La syntaxe est :

nHc1 c2c3c4 ... cn avec : n une constante entière positive, différente de zéro, indiquant le nombre de caractères contenu

dans la chaîne, espaces compris; H le descripteur Hollerith; ci un caractère ASCII, leur nombre ne devant pas dépasser les limites de chaque implémentation. Exemples :

4H**** 15HTitre du dessin 11HAujourd'hui

Si la longueur de la constante Hollerith est plus petite que la longueur imposée par le compteur de caractères, des espaces sont ajoutés à droite de la constante. Si la longueur de la constante est plus grande que la longueur imposée par le compteur, la constante est tronquée à droite. Une erreur intervient si des caractères différents de l'espace sont tronqués.

2.3 VARIABLES SIMPLES Dans le langage FORTRAN , une variable simple est caractérisée par : 1. son identificateur ou nom symbolique; 2. son type; 3. la place occupée en mémoire par cette variable, soit le nombre d'octets. L'identificateur de la variable suit les règles citées précédemment : le premier caractère doit être une lettre, les caractères suivants étant des lettres ou des chiffres, leur nombre ne devant pas dépas-ser six selon la norme ANSI , certains compilateurs admettant plus de 6 caractères. Les variables sont classées en type tout comme les constantes. Le type fixe le nombre d'octets nécessaire à la repré-sentation interne de la donnée selon les règles citées au chapitre 2.1 . L'identificateur de variable peut être considéré comme une interface entre le programme source ou le programmeur et l'adresse réelle de la variable en mémoire. FORTRAN connaît la déclaration implicte des variables de type integer et real . Les autres types de variables nécessitent toujours une déclaration générale ou particulière. Par défaut, toutes les variables non déclarées commençant par : 1. la lettre i à la lettre n sont de type integer ; 2. toutes les autres variables, dont la première lettre est a jusqu'à h et o jusqu'à z sont de type real . Deux points de vue diamétralement opposés sont actuellement introduits dans la programmation FORTRAN : 1. les déclaration implicites par défaut sont conservées dans toutes les unités de programme et

seuls les autres types sont déclarés. Cette façon de procéder permet de distinguer très facilement les variables de type integer ou real des autres types de données.

2. les déclarations par défaut sont abandonnées, bien que toujours applicables, et toutes les variables de chaque unité de programme sont déclarées. Cette méthode se prête bien à la pro-grammation structurée utilisant de nombreux sous-programmes.

Remarques très importantes Le compilateur FORTRAN ne contrôle pas si toutes les variables utilisées dans l'unité de pro-gramme ont fait l'objet d'une déclaration, la déclaration par défaut étant introduite chaque fois qu'une

- 21 -


variable ne figure pas dans une instruction de spécification. La tendance actuelle est de déclarer les variables de chaque unité de programme. Un problème important peut surgir dans les sous-programmes lorsque les types integer*2 et integer*4 sont employés simultanément et sont passés comme paramètres formels, affectés par des constantes entières. 2.3.1 SPÉCIFICATION DE TYPE PAR IMPLICIT Le langage FORTRAN fixe les déclarations implicites seulement pour les variables de type integer et real . Il est possible de modifier cette convention implicite et d'étendre les spécifications pour tous les types à disposition au moyen de l'instruction :

implicit type (letinij-letfinj [, ... ] ) avec : type un des spécificateurs de type reconnu par le compilateur, letinij lettre initiale de l'ensemble des lettres de l'identificateur, leffinj lettre finale de l'ensemble des lettres de l'identificateur, letinij doit précéder alphabétiquement leffinj et peut figurer seul dans les parenthèses. Exemples :

implicit real*8 (d-f) implicit integer*2 (i-k) , integer*4 (l-n) implicit complex (z)

VAX-11 connaît la suppression de toutes les déclarations implicites par une instruction : implicit none . Dans ce cas, toutes les variables doivent se déclarer dans l'unité de programme. Les spécifications de l'instruction implicit ne s'appliquent jamais aux identificateurs des fonctions de la librairie FORTRAN. L'instruction n'est valable que dans l'unité de programme et toute déclaration explicite du type d'une fonction programmée supprime la spécification implicite. Les déclarations implicites doivent faire l'objet d'un contrôle attentif des identificateurs, surtout si l'unité de programme contient beaucoup d'instructions. Il est recommandé : 1. de conserver aux variables de type integer, integer*2 et integer*4 des identificateurs com-

mençant par l'une des lettres de l'intervalle i .. n . 2. de conserver aux variables de type real, real*4 des identificateurs commençant par l'une des let-

tres n'appartenant pas à l'intervalle i .. n . 3. d'introduire l'instruction implicit seulement dans des cas exceptionnels comme dans le dernier

exemple ci-dessus pour toutes les variables de type complex . 4. de déclarer explicitement les autres ou toutes les variables dans chaque unité de programme en

choisissant un nom de variable correspondant à la fonction de la donnée à représenter. Dans une instruction de déclaration de type d'une ou de plusieurs variables, ces variables appar-tenant à la liste des variables (liste de variables) des syntaxes citées ci-après, il faut : 1. un espace entre la déclaration du type et la première variable citée dans la liste; 2. séparer chaque variable de la liste de la suivante par une virgule; 3. que l'identificateur attribué à une variable ne soit pas affecté à une autre variable simple ou indi-

cée dans la même unité de programme, ou ne soit pas un identificateur global du programme ou de sous-programmes.

2.3.2 VARIABLES DE TYPE INTEGER Sans spécification particulière, les identificateurs des variables entières de type integer, integer*2 ou integer*4 (selon la directive de compilation active), commencent par l'une des lettres suivantes (les limites sont données par les deux premières lettres de type integer ) :

i,j,k,l,m,n

- 22 -


Si l'on désire utiliser d'autres lettres initiales ou déclarer explicitement les variables de type integer , l'instruction de spécification peut prendre l'une des formes suivantes :

integer liste_de_variables integer*2 liste_de_variables integer*4 liste_de_variables La première spécification déclare des variables de type integer occupant 4 octets chacune en mémoire, à moins qu'une directive de compilation prévoit des entiers à 2 octets. Si l'on désire imposer le nombre d'octets pour chaque variable, sans possibilité de modification par une directive générale, il faut introduire alors dans l'instruction : integer*2 ou integer*4 . Exemples de variables entières : 1. Sans déclaration explicite de type :

nouvea igloo mauve joujou libere

2. Avec déclaration explicite :

integer*2 neuf , noml1 , nul integer*4 jeux , kilos , long 2.3.3 VARIABLES DE TYPE REAL Sans déclaration particulière, les identificateurs de variables réelles commencent par l'une des lettres suivantes

a,b,c, ... g,h,o,p, ... ,x,y,z Il est possible de s'affranchir de cette convention ou de déclarer les identificateurs utilisés dans l'unité de programme au moyen d'une des déclarations de type suivantes :

real liste_de_variables real*4 liste_de_variables Exemples de variables réelles : 1. Sans déclaration explicite de type :

bonne annee pauvre roue temps

2. Avec déclaration explicite de type : real osibar , amaxl1 , aminl1 real*4 epsi , faveur , grands

Si dans l'unité de programme, on désire utiliser un identificateur dont la lettre initiale correspond à celle d'une variable de type entier, il est possible de lui adjoindre un préfixe différent des lettres réservées aux variables de type entier. 2.3.4 VARIABLES DE TYPE DOUBLE PRECISION Chaque variable en double précision peut contenir une constante en double précision stockée dans 8 octets, ou éventuellement dans 16 octets seulement pour VAX-11 (voir sous 2.1.4). La déclaration obligatoire de l'identificateur de la variable en double precision prend l'une des formes sui-vantes :

double precision_ liste_de_variables real*8 liste_de_variables real*16 liste_de_variables

- 23 -


Exemples de variables en double précision :

double precision dceta , dangle , dimax9 real*8 dbeta , dsomme , dgrand 2.3.5 VARIABLES DE TYPE COMPLEX Chaque variable complexe doit pouvoir contenir deux données réelles ou en double précision, la première étant la partie réelle, la seconde la partie imaginaire de la grandeur complexe. Pour qu'une variable soit reconnue comme variable complexe, il faut déclarer obligatoirement son identificateur comme tel sous l'une des formes suivantes :

complex liste_de_variables complex*8 liste_de_variables complex*16 liste_de_variables Exemples de variables complexes :

complex zerep , bonhar , crepe complex*8 temps , tordre , tarot 2.3.6 VARIABLES DE TYPE LOGICAL Une variable logique contient l'une des deux valeurs d'une expression logique : .true. ou .false.. Pour qu'une variable puisse être de type logical , il faut déclarer obligatoirement son identificateur comme tel en début de programme au moyen de l'une des instructions :

logical liste_de_variables logica1*2 liste_de_variables logical*4 liste_de_variables La première déclaration réserve 4 octets en mémoire par variable à moins qu'une directive de compilation limite la place à 2 octets par défaut. Les deux autres spécifications fixent sans équivoque l'occupation en mémoire, indépendamment de la présence ou non d'une directive particulière. Exemples de variables logiques :

logical*4 lcomp bon44 , cvrai logical vrais5 , cfaux , cmall 2.3.7 VARIABLES DE TYPE CHARACTER La déclaration d'une ou de plusieurs variables de type chaîne de caractères prend l'une des deux formes suivantes :

character*n liste_de_variables character v1*n1,v2*n2, ... , vm*nm avec : n nombre maximal de caractères de la chaîne correspondant au nombre maximal d'octets réservé

en mémoire. Ce nombre ne doit pas dépasser la valeur maximale dépendant de l'implémentation de FORTRAN .

vi identificateur de variable de type chaîne de caractères. Exemples de variables chaîne de caractères character*12 texte , page , ligne

- 24 -


character mot*8 , entete*20 , chaine*16

Dans le premier exemple, la première ligne réserve 12 caractères pour les variables texte , page et ligne tandis que la seconde déclaration réserve 8 caractères pour la variable mot , 20 caractères pour entete et 16 caractères pour chaine .

Une forme particulière de spécification intervient dans la déclaration de variables de type character dans les sous-programmes lorsque cette ou ces variables sont citées dans la liste des paramètres formels :

character*(*) parametre_formel Le nombre de caractères de la chaîne, qui peut varier d'un appel à l'autre du sous-programme, dépend d'une définition des variable de type character située à un niveau directement supérieur. Exemple d'un début de fonction programmée :

integer function imax (cvar) character*(*) cvar . . . . . . . . end

Le nombre maximal de caractères de cvar ne peut pas dépasser la dimension maximale spécifiée pour le paramètre effectif correspondant à cvar dans l'instruction d'appel de la fonction imax .

2.4 VARIABLES DE TABLEAUX Une variable indicée ou de tableau (array) est un groupe de places consécutives en mémoire, désigné par un identificateur commun. Chaque élément du tableau est repéré par un ou plusieurs indices, placés entre parenthèses, séparés par la virgule, qui suivent directement l'identificateur. Une variable indicée à une dimension est appelée vecteur. Celle à deux dimensions est dénommée matrice ou tableau à lignes et colonnes, celle à trois dimensions à lignes, colonnes et pages pourrait se désigner par volume, etc. FORTRAN admet des tableaux jusqu'à 7 dimensions. Tous les éléments d'un même tableau doivent être obligatoirement du même type. La déclaration d'une variable indicée doit s'effectuer dans chaque unité de programme où elle est employée au moyen de l'une des instructions suivantes : 1. instruction de déclaration de type, 2. instruction dimension , 3. instruction common . Ces diverses instructions contiennent les spécifications des variables qui définissent les identificateurs, suivis des dimensions et des limites des indices pour chaque dimension. La classification des identificateurs de variables indicées obéit aux mêmes règles que celles des variables simples. Le type d'une variable indicée est identifié soit implicitement à partir de la première lettre du nom symbolique dans l'instruction dimension , soit explicitement dans une spécification de type. Les variables simples et indicées peuvent se placer dans la même instruction. 2.4.1 DÉCLARATION D'UNE VARIABLE INDICÉE Une déclaration de variables indicées spécifie l’un des types de variable et le ou les identificateurs correspondants, accompagnés du dimensionnement. La syntaxe générale est :

type identif (d1 [, d2 ] … ) [ , … ] avec : identif nom symbolique attribué à la variable indicée, d1,d2, dimension(s) limite(s) des indices.

- 25 -


dj peut spécifier soit la limite supérieure de l'indice, la limite inférieure étant 1 par défaut, soit les limites inférieure et supérieure. La syntaxe d'une dimension est :

[ di ::] ds di limite inférieure de l'indice, ds limite supérieure de l'indice. La limite inférieure de l'indice peut être négative, nulle ou positive. La limite supérieure de l'indice doit être plus grande ou égale à la limite inférieure. Le nombre d'éléments d'une dimension est donné par l'expression : ds - di + 1 . La limite supérieure du dernier indice peut être écrite par l'astérisque, cette manière de procéder n'étant applicable qu'au dimensionnement dans les sous-programmes pour des tableaux dont la dimension est fixée à un niveau supérieur. Chaque limite est une expression arithmétique de type integer , dans laquelle chaque opérande est une constante, un paramètre formel ou une variable d'un bloc common . L'instruction habituelle fait mention des dimensions sous forme de constantes entières. VAX-11 admet des expressions de type différent qui sont converties en type integer (hors norme). Le nombre total d'éléments pouvant se stocker dans une variable de tableau est égal au produit des nombres d'éléments de chaque dimension. La spécification des dimensions de variables de tableaux dans un sous-programme peut être une expression variable, voir chapitre 4 . L'identificateur de variable, avec ses dimensions, ne peut appa-raître que dans une instruction de spécification dans l'unité de programme. 2.4.2 VARIABLES DE TYPE INTEGER L'instruction de spécification pour des variables de tableaux de type integer peut prendre l'une des formes suivantes :

integer identif (d1 [,d2] … ) [, … ] integer*4 identif (d1 [,d2] … ) [, … ] integer*2 identif (d1 [,d2] … ) [, … ] La spécification integer impose un stockage de chaque élément de type entier dans 4 octets de la mémoire à moins qu'une directive de compilation fixe un stockage dans 2 octets. Exemples de variables indicées entières :

integer irma(10,20) integer*4 jeu(0:100) , kiwi(5,20) integer*2 moins(-10:10)

Dans ces exemples, les variables citées comprennent :

irma ---- 200 éléments et 800 octets jeu ---- 101 éléments et 404 octets kiwi ---- 100 éléments et 400 octets moins ---- 21 éléments et 42 octets 2.4.3 VARIABLES DE TYPE REAL L'instruction de spécification pour des variables de tableaux de type real peut prendre l'une des formes suivantes :

real identif (d1 [,d2] … ) [, … ] real*4 identif (d1 [d2] … ) [, … ] Ces deux spécifications imposent un stockage de chaque élément de type real dans 4 octets de la mémoire en trois parties : signe, exposant et mantisse.

- 26 -


Exemples de variables indicées réelles :

Real amax(20) , vecteu(0:100) , bmatr (100,100) real*4 valeur(0:50) , zebre(20,200) 2.4.4 VARIABLES DE TYPE DOUBLE PRECISION L'instruction de spécification des variables de tableaux de type double precision peut prendre l'une des formes suivantes :

double precision identif ( d1 [,d2] … ) [, … ] real*8 identif ( d1 [,d2] … ) [, … ] real*16 identif ( d1 [,d2] … ) [, … ] Les deux premières spécifications imposent un stockage de chaque élément réel en double precision dans 8 octets de la mémoire en trois parties : signe, exposant et mantisse. VAX-11 , avec coprocesseur étendu, admet le type real*16 . Exemples de variables indicées en double précision :

double precision double(25) , quatre(100,50) real*8 fois2(100) , dans4(10,0:100,5) 2.4.5 VARIABLES DE TYPE COMPLEX L'instruction de spécification pour des variables de tableaux de type complex peut prendre l'une des formes suivantes :

complex identif ( d1 [,d2] … )[, …] complex*8 identif (d1 [,d2] … )[, …] complex*16 identif (d1 [d2] … )[, …] Les deux premières spécifications impose un stockage de chaque élément de type complex dans 8 octets de la mémoire, les 4 premiers contenant la partie réelle et les 4 suivants la partie imaginaire. La dernière spécification permet de stocker un élément de type complex dans 16 octets sous forme de données numériques en double precision . Exemples de variables indicées complexes :

complex zplus(5,10) complex*8 zorro (0:50) complex*16 zebus(-10:20) 2.4.6 VARIABLES DE TYPE LOGICAL L'instruction de spécification pour les variables logiques de tableaux peut prendre l'une des formes suivantes :

logical identif (d1 [,d2] … ) [, … ] logical*4 identif (d1 [,d2] … ) [, … ] logical*2 identif ( d1 [,d2] … ) [, … ] Les deux premières spécifications imposent un stockage de chaque élément de type logical dans 4 octets de la mémoire, à moins qu'une directive de compilation impose un stockage de 2 octets pour logical . La dernière spécification prévoit un stockage dans 2 octets pour chaque élément du tableau.

- 27 -


Exemples de variables indicées logiques :

logical loups(20) , loriot(12,6) logical*4 juste(16) , joujou(40) logical*2 boubs(-5:19) , bonne(2,16) 2.4.7 VARIABLES DE TYPE CHARACTER L'instruction de spécification pour des variables de type character peut prendre l'une des deux formes suivantes :

character*n identif ( d1 [,d2] … ) [, … ] character identif ( d1 [,d2] … )*n [, … ] avec : n nombre maximal de caractères de tous les éléments de toutes les chaînes de caractères dans la

première instruction, n nombre maximal de caractères de tous les éléments d'une variable dans la seconde instruction,

chaque variable pouvant avoir un nombre différent de caractères. Exemples de variables indicées chaîne de caractères :

character*16 famil0 (250) character ville(125)*25 , prenom (80)*20 2.4.8 RANGEMENT DES ÉLÉMENTS D'UNE VARIABLE Dans la discussion des dimensions d'une variable de tableau et de la position des éléments dans ce tableau, la première dimension est nommée habituellement indice de ligne, la seconde dimension indice de colonne, la troisième indice de page, etc. Les éléments sont stockés en mémoire dans des places contiguës, octet après octet, l'organisation de ce rangement étant assuré par le compilateur ou les définitions du langage FORTRAN . La règle générale, applicable à tous les types de tableaux, est la suivante :

Le rangement en mémoire des éléments d'une variable indicée est effectué de telle sorte que l'indice le plus à gauche varie le plus souvent.

Dans les figures ci-après, la représentation des éléments dans la mémoire pourrait se dessiner sous la forme imagée suivante. Le numéro figurant devant l'identificateur de tableau est le numéro de rangement de l'élément en mémoire.

1. Tableau à une dimension : vecteur AAB(6)

1 AAB(1) 2 AAB(2) 3 AAB(3) 4 AAB(4) 5 AAB(5) 6 AAB(6)

2. Tableau à deux dimensions : matrice ABB(3,5) 1 ABB(1,1) 4 ABB(1,2) 7 ABB(1,3) 10 ABB(1,4) 13 ABB(1,5) 16

2 ABB(2,1) 5 ABB(2,2) 8 ABB(2,3) 11 ABB(2,4) 14 ABB(2,5) 17

3 ABB(3,1) 6 ABB(3,2) 9 ABB(3,3) 12 ABB(3,4) 15 ABB(3,5) 18

- 28 -


3. Tableau à trois dimensions : ABC(3,3,2)

Dans cette dernière représentation, les éléments sont placées comme sur des pages. 2.4.9 INSTRUCTION DIMENSION Cette instruction générale est surtout utilisée lorsque le type de variable est fixé implicitement, donc pour les variables indicées de type integer ou real , ou encore lorsque l'instruction implicit a été employée pour fixer un des types existants :

dimension identif (d1 [,d2] … )[, … ] avec : identif nom symbolique attribué à la variable indicée, d1,d2, limites du nombre d'éléments de chaque dimension. La syntaxe des limites de dimension est la même que pour les spécifications de type. Le nombre d'éléments par dimension est encore donné par : ds - di + 1 . Si la dimension est un paramètre formel ou une variable entière provenant de l'instruction common , la dimension est égale à la valeur initiale de la variable au départ du sous-programme. Si la dernière dimension est fixée par l'astérisque, la limite supérieure de la dimension n'est pas fixée à ce niveau. Exemples :

dimension beau(10,20,5) dimension vue (5,5,5) , ireel(20,50) dimension marque (0:100)

subroutine envie (a,b,c,l,m,n) dimension a(l,n) , b(n:*)

2.5 EXPRESSIONS FORTRAN Une expression FORTRAN se compose d'un ou de plusieurs opérandes reliés entre eux par des opérateurs appropriés. Les expressions sont classées en : 1. expressions arithmétiques, 2. expressions chaînes de caractères, 3. expressions relationnelles, 4. expressions logiques.

- 29 -


Les expressions arithmétiques opèrent sur des données numériques, les expressions de type caractère sur des valeurs de type character , les expressions logiques ou relationnelles produisent des valeurs booléennes ou logical . 2.5.1 EXPRESSIONS ARITHMÉTIQUES Une expression arithmétique produit une valeur qui est de type : integer, real, double precision ou complex . Les composants élémentaires d'une expression arithmétique sont, à part les opérateurs arithmétiques : 1. une constante, 2. une référence à une variable, 3. une référence à un élément d'une variable indicée, 4. une référence à une fonction. 2.5.1.1 OPÉRATEURS ARITHMÉTIQUES Les opérateurs arithmétiques permettent d'effectuer les quatre opérations fondamentales et l'exponentiation.

Tableau 2.2 OPÉRATEURS ARITHMÉTIQUES FORTRAN

Opérateurs Priorités Fonction

** * / + -

1 2 2 3 3

Exponentiation MultiplicationDivision Addition Soustraction

La qualification numérique peut s'appliquer également aux valeurs logiques utilisées comme valeurs entières dans une expression arithmétique, par exemple VAX-11 (hors norme). Les opérateurs arithmétiques sont donnés dans le tableau 2.2 , classés par ordre de priorité. Exemples :

2.0*tout-4.0*somme/nombre+0.1*reste 3.0*force*along**3/48.0 alarge*haut**2/6.0

Remarques : 1. Toute variable ou élément de variable indicée utilisé dans une expression arithmétique doit être

définie avant son évaluation dans cette expression. Si la variable n'a pas été affectée d'une valeur numérique, cette variable vaut habituellement zéro sans que le programme signale une erreur. Si une opération interdite intervient, comme par exemple une division par zéro, une erreur d'exé-cution provoque l'arrêt du programme avec affichage d'un ou de plusieurs messages d'erreur.

2. Deux opérateurs arithmétiques ne peuvent pas se suivre : par exemple, l'écriture de a*-b est incorrecte. Cette expression arithmétique doit s'écrire : a *(-b) .

3. En présence d'opérateurs de même priorité dans la même expression arithmétique, l'évaluation numérique s'effectue de gauche à droite, sauf pour l'exponentiation qui est évaluée de droite à gauche.

Exemple :

a**b**c est équivalent à : a**(b**c)

- 30 -


4. L'emploi de parenthèses peut modifier l'ordre d'évaluation d'une expression arithmétique. Une expression avec parenthèses est calculée à partir de l'expression parenthésée la plus intérieure.

5. Il est recommandé de toujours vérifier le nombre de parenthèses gauches et le nombre de parenthèses droites. Ces deux nombres doivent être égaux. Si l'on n'est pas très sûr de la syntaxe d'une expression par priorité d'opérateurs, il est sage de parenthéser une expression arithmétique un peu compliquée.

2.5.1.2 RÈGLES D'HOMOGÉNÉITE DES TYPES En principe, tous les éléments constitutifs d'une expression arithmétique devraient s'exprimer dans le même type afin que les opérations puissent s'effectuer sur des données de même représentation interne. Ces règles d'homogénéité sont de plus en plus abandonnées et les compilateurs actuels admettent dans une large mesure des expressions hétérogènes. Toutefois, un bon programmeur doit penser, dans la mesure du possible, d'éviter toute transformation de type pendant l'opération de traduction du programme source en langage machine, par exemple en écrivant les constantes entières ou réelles correctement. L'adjonction du zéro après le point décimal d'une constante de type real sans partie décimale facilite fortement la lecture du programme source et diminue le temps de compilation. La priorité des types est donnée dans le tableau 2.3.

Tableau 2.3 NIVEAUX DES TYPES

Type Niveau

logical integer*2 integer*4 real 4 real*4 double precision real*8 complex*8 complex*16

1 (le plus bas) 2 3 4 4 5 5 6 7 (le plus haut)

Si tous les opérandes d'une expression arithmétique sont de même type, l'expression résultante est également de ce type. Si les composantes sont de divers types, le résultat dépend du niveau attribué à chaque type. En addition, soustraction, multiplication et division, le compilateur combine et transforme les opérandes arithmétiques suivant le tableau 2.4 donnant les types du premier et du second opérande, du résultat de l'opération effectuée.

Tableau 2.4 OPÉRATIONS ARITHMÉTIQUES

Résultat d’une opération arithmétique (+,-,*,/)

Type du second opérande Type du premier Opérande Integer real double complex

integer real double precision complex

integerreal

double complex

real real

double complex

double double double complex

Complex Complex Complex complex

- 31 -


Remarques :

1. Opérations sur les entiers Les opérations arithmétiques ne peuvent s'effectuer que sur des opérandes entiers, les opérandes logiques étant traités comme des entiers dans un contexte arithmétique. En arithmétique sur les en-tiers, le résultat d'une division est tronqué et non pas arrondi. Exemple :

1/3+1/3+1/3 égal zéro et non pas un, car chaque division donne zéro

Les opérations entre des entiers de types integer*4 et integer*2 donnent des résultats en type integer*4 .

2. Opérations sur les réels Les opérations arithmétiques ne peuvent s'effectuer que sur des opérandes réels ou une combi-naison de réels, entiers et logiques. Tout opérande entier est transformé en valeur de type real en lui donnant la partie décimale égale à zéro. Les opérations arithmétiques sont effectuées en arithmétique des réels, c'est-à-dire à partir de la représentation en trois composantes : signe, exposant et mantisse. Notez que dans l'expression (i /j)*a , la division de i par j s'effectue en premier sur une entité de type integer, donc en tronquant la partie décimale ! La multiplication par a nécessite donc tout d'abord la transformation de (i /j) en valeur de type real.

3. Opérations sur les grandeurs en double précision Les opérandes entiers et réels sont convertis en type double precision par adjonction de zéros, la conversion n'augmentant nullement la précision ou le nombre de chiffres significatifs de la partie décimale du nombre. L'expression est alors calculée en arithmétique double precision.

4. Opérations sur les complexes Dans ce genre d'opérations, les opérandes entiers sont convertis en valeur de type real comme ci-dessus. Les opérandes en double precision sont tronqués, arrondis et transformés en valeur de type real. L'opérande réel obtenu représente la partie réelle du nombre complexe; la partie imaginaire est égale à zéro. L'expression est alors évaluée en arithmétique des grandeurs complexes et le résultat est de type complex . Les opérations arithmétiques faisant intervenir simultanément des opérandes de type complex*8 et real*8 imposent l'évaluation en arithmétique complex*16, les opérandes real*8 n'étant pas arrondis (seulement pour VAX-11). 2.5.1.3 EXPONENTIATION Les possibilités d'exponentiation des expressions arithmétiques sont limitées et données dans le tableau 2.5.

Tableau 2.5 POSSIBILITÉS D'EXPONENTIATION EN FORTRAN

Type du résultat de l'exponentiation

Type de l’exposant Type de l’élément de base

integer real double complex

integer real double precision complex

integerreal

double complex

real real

double complex

double double double

complex*16

complex complex

complex*16 complex

- 32 -


complex*16 seulement pour les compilateurs ayant cette représentation en double précision

Remarques complémentaires : Un opérande négatif peut être élevé seulement à une puissance entière. Un opérande valant zéro ne peut pas être élevé à la puissance zéro. Si l'opérande est à élever à une puissance entière, pro-grammez cet exposant en type integer plutôt qu'en type real . 2.5.2 EXPRESSIONS DE TYPE CHARACTER Les expressions de type character se composent d'opérandes de type character. L'évaluation d'une expression de type character s'effectue en combinant les opérandes et en donnant une valeur de type character au résultat. Un opérande de type character peut être : 1. une constante de type character, 2. une variable simple de type character, 3. un élément de tableau de type character, 4. une sous-chaîne de type character, 5. une fonction de type character. 2.5.2.1 CONCATÉNATION La seule opération reconnue par FORTRAN , sur les opérandes de type character, est la conca-ténation de chaînes, c'est-à-dire l'addition des suites de caractères. L'opérateur de concaténation est la double barre oblique, sans espace. Exemple :

nom//prenom//ville 2.5.2.2 SOUS-CHAINES DE TYPE CHARACTER Une sous-chaîne de type character est une suite de caractères placée dans une partie d'une variable ou d'un élément de variable indicée de type character. La syntaxe générale de la sous-chaîne est :

identif ([prem]:[dern]) avec : identif un identificateur de variable simple de type character, un identificateur d'un élément de variable indicée de type character, prem expression entière spécifiant la position la plus à gauche du premier caractère de la sous-

chaîne, dern expression entière spécifiant la position la plus à droite du dernier caractère de la sous-

chaîne. Les caractères de la variable ou de l'élément de la variable indicée chaîne de caractères sont numérotés de gauche à droite, le premier caractère portant le numéro 1. Si les expressions pour prem et dem ne sont pas de type integer, elles sont converties en type integer avant utilisation (VAX-11). Les valeurs des expressions prem et dem doivent remplir les conditions suivantes : 1 <= prem <= dern <= len len étant la longueur réelle de la chaîne attribuée à la variable ou à l'élément de tableau de type character. Si la valeur prem est omise, prem = 1 par défaut et si la valeur dem est omise, alors dern = len . Exemples :

- 33 -


Chaîne initiale : chaine = 'programmation_FORTRAN'

Sous-chaînes tirées de la chaîne initiale : chaine(4:10) correspond à ‘grammat’ chaine(:5) correspond à 'progr' chaine(10:) correspond à 'tion—FORTRAN'

Dans la première spécification, la sous-chaîne comprend tous les caractères numérotés de 4 à 10, dans la seconde, tous les caractères de 1 à 5 et finalement dans la troisième, tous les caractères de 10 à len . 2.5.3 EXPRESSION DE RELATION Une expression de relation se compose d'expressions arithmétiques et/ou de type character reliées entre elles par un ou plusieurs opérateurs de relation. La valeur de l'expression est vraie si la relation proposée entre les opérandes existe, elle est fausse dans le cas contraire. Le résultat de la relation est donc de type logical .

Tableau 2.6 OPÉRATEURS DE RELATION EN FORTRAN

- Opérateurs - Relation réalisée

.eq.

.ne.

.1t.

.le.

.gt.

.ge.

égal à : différent de inférieur à inférieur ou égal à : plus grand que supérieur ou égal à :

Une expression de relation se compose d'expressions arithmétiques et/ou de type character reliées entre elles par un ou plusieurs opérateurs de relation. La valeur de l'expression est vraie si la relation proposée entre les opérandes existe, elle est fausse dans le cas contraire. Le résultat de la relation est donc de type logical . Tous les opérateurs relationnels sont des opérateurs binaires et se placent entre leurs opérandes. Les opérateurs relationnels ne peuvent pas s'introduire entre deux valeurs logiques. Remarques : 1. Un opérateur de relation peut comparer des expressions numérique de types différents, la donnée

du niveau le plus bas étant convertie en celle du niveau le plus élevé. 2. Avec les expressions de type complex , seuls les opérateurs : .eq. et .ne. peuvent s'employer

dans l'évaluation. 3. Le résultat de l'évaluation d'une expression de relation est soit la valeur logique .true. , soit la

valeur logique .false. . 4. Les expressions arithmétiques étant évaluées avant l'opération de relation, il n'est pas néces-

saire de mettre ces dernières entre parenthèses. Par contre, la présence de parenthèses aug-mente très souvent la lisibilité de l'expression.

5. Les deux points font partie intégrante de l'écriture correcte de l'opérateur de relation. 6. Deux opérateurs de relation ne peuvent pas se suivre ou deux opérateurs ne peuvent encadrer un

seul opérande dans une expression FORTRAN . 7. Dans une relation entre expressions avec des entités de type character , les expressions sont

évaluées et les résultats sont comparés. La comparaison s'effectue en utilisant le classement selon ASCII , les caractères étant oscultés les uns à la suite des autres. Si les opérandes sont de

- 34 -


longueurs différentes, l'opérande le plus court est étendu à la taille du plus long par adjonction de caractères espace à droite.

Exemples de relations :

pomme+poire .gt. peche+orange 'abcdef' .lt. 'baba'

Dans le premier exemple, la relation est vraie si la somme des valeurs numériques affectées aux variables pomme et poire est plus grande que la somme des valeurs affectées aux variables peche et orange . Dans le cas contraire, le résultat de la relation est faux. Les variables utilisées ici sont de type real en l'absence d'une déclaration particulière. Dans le second exemple, la relation entre les deux constantes est vraie car une comparaison caractère après caractère des deux chaînes montre que 'abcdef' possède le premier caractère 'a' qui précède le premier caractère 'b' de la seconde constante 'baba'. 2.5.4 EXPRESSIONS LOGIQUES Les expressions logiques se composent d'opérandes logiques et d'opérateurs logiques. Les opérandes d'une expression logique peuvent être : 1. une constante de type logical, 2. une variable de type logical, 3. un élément de type logical d'une variable indicée, 4. une expression relationnelle, 5. une référence à une fonction logique. Les autres expressions logiques sont formées de composantes simples, placées entre parenthè-ses si nécessaire, et des opérateurs logiques. Le résultat de l'expression est soit .true. , soit .false. . 2.5.4.1 OPÉRATEURS LOGIQUES Les opérateurs logiques FORTRAN permettent d'assembler des entités de type logical au moyen d'opérateurs classiques de la logique. Tableau 2.7 OPÉRATEURS LOGIQUES EN FORTRAN

Opérateurs logiques

Opérateur Exemples Signification

.and.

.or.

.eqv.

.neqv.

.not.

a .and. b

a .or. b

a .eqv. b

a .neqv. b

.not. b

l'expression est vraie si et seulement si a et b sont .true. l'expression est vraie si soit a, soit b, soit les deux sont .true. l'expression est vraie si a et b ont la même valeur logique, soit .true. , soit .false. l'expression est vraie si a est .true. et b est .false. ou vice versa; elle est fausse si les deux opérandes ont même valeur logique (= à .xor.) l'expression est vraie si b est .false. ou elle est fausse si b est .true.

- 35 -


2.5.4.2 PRIORITÉ DES OPÉRATEURS L'ordre de priorité d'exécution des divers opérateurs arithmétiques, de relation ou logiques est donné dans le tableau 2.8 . Les expressions avec des opérateurs de même priorité sont évaluées de gauche à droite. Deux opérateurs logiques ne peuvent pas se suivre, sauf si le second est .not. . Les expressions parenthé-sées sont évaluées en premier.

Tableau 2.8 PRIORITÉ DES DIVERS OPÉRATEURS FORTRAN

Opérateurs Fonction Priorité

** * / + -

//

.eq.

.ne.

.lt.

.le.

.gt.

.ge.

.not.

.and. .or.

.eqv. .neqv.

exponentiation multiplication division addition soustraction

concaténation

égal différent inférieur inférieur ou égal supérieur supérieur ou égal

négation

ET OU

équivalent non équivalant

1 la plus haute 2 2 3 3

4

5 5 5 5 5 5

6

7 8

9 9 la plus basse

2.5.4.3 EXEMPLES Les exemples partiels suivants montrent l'utilisation d'expressions logiques. L'utilisation de pa-renthèses facilite très souvent la lecture de l'instruction. Exemples :

a*b+c*abc .eq. x*y+dm/zz .and. .not. k*b .gt. tt

Cette instruction contenant plusieurs opérateurs logiques s'évalue selon la configuration suivante, les parenthèses ayant été introduites pour montrer le principe du traitement de l'instruction. La partie la plus parenthésée est calculée en premier :

(((a*b)+(c*abc)).eq.((x*y)+(dm/zz))).and.(.not.((k*b).gt.tt)

Dans certains cas, l'expression logique n'est pas entièrement évaluée si la condition logique recherchée est déjà trouvée avant la fin des opérations sur l'instruction complète. Si dans l'exemple qui suit a , variable logique, est affectée de la valeur .false. : a .and. (f(x,y) .gt. 2.0) .and. b

- 36 -


alors la valeur de l'expression est déjà fixée par le test sur la valeur de a sans avoir à calculer la valeur de la fonction f (x,y) ; ainsi, le sous-programme function f (x,y) n'est pas du tout appelé.

Exemple supplémentaire : Le programme partiel suivant démontre l'utilisation des opérateurs logiques.

* * Expressions logiques * logical stop , va , attend , a , b , c , d , e

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

* * Les 2 instructions suivantes sont équivalentes * stop = a .and. b .and. c stop = (a .and. b) .and. c * * Les 2 instructions suivantes sont aussi équivalentes * va = .not. a .or. b .and. c va = ((.not. a) .or. b) .and. c * * Les 2 instructions suivantes sont aussi équivalentes * attend = .not. a .eqv. b .or. c .neqv. d .and. e attend = ((.not. a) .eqv. (b .or. c)) .neqv. (d .and. e)

- 37 -

CHAPITRE 3

INSTRUCTIONS DE BASE Ce chapitre traite des instructions de base du langage FORTRAN permettant de créer les struc-tures séquentielles, sélectives et itératives. Les instructions nécessaires à la structuration des sous-programmes et les vastes possibilités d'opérations en entrée - sortie (E/S ou en anglais I/O pour input - output) seront décrites dans les deux chapitres 4 et 5 .

3.1 STRUCTURES SÉQUENTIELLES Une partie de programme à structure séquentielle est une suite d'instructions FORTRAN traitée ligne après ligne, sans sauts ni répétitions. L'un des reproches fait au langage est l'utilisation abusive de branchements et d'étiquettes afin d'atteindre des instructions déterminées dans le programme. Dans les exemples de ce cours, nous voulons essayer de supprimer cette ancienne tradition en décomposant le programme en tâches distinctes et en évitant les étiquettes. 3.1.1 INSTRUCTION PARAMETER L'instruction parameter affecte un nom symbolique à une constante numérique, logique ou alphanumérique. La syntaxe prend la configuration suivante :

parameter (identif1 = const1 [ ,identif2 = const2, …]) avec : identifi un identificateur de constante, consti une constante ou une expression numérique, logique ou alphanumérique. La valeur de la constante est transformée dans le même type que l'identificateur si c'est néces-saire. Si consti est une expression, elle ne peut pas contenir de variables, d'éléments de variables indicées ou de référence à une fonction. L'instruction parameter est placée en tête de programme, dans la partie des spécifications. Si le type de l'identificateur est spécifié, cette déclaration doit figurer avant l'instruction parameter L'identificateur ne peut se définir qu'une seule fois dans l'unité de programme. La valeur attribuée à l'identificateur ne peut pas être modifiée, car l'identificateur n'est pas une variable mais un nom attribué à une constante. La définition de la constante n'est applicable qu'à l'intérieur de l'unité de programme. Exemples :

integer*2 i,maxi real*4 aire,pi,rayon parameter (maxi=50 , pi=3.141593) ..... aire = pi * rayon**2 do i = 1,maxi ..... end do

Il est possible d'utiliser les astérisques dans la déclaration du type de l'identificateur si cette entité est définie par la suite dans une instruction parameter .

- 38 -

- 3. Instructions de base en Fortran 77 -

Exemple :

character*(*) granmo parameter (granmo = 'anticonstitionnellement') 3.1.2 INSTRUCTION DATA L'instruction data est une instruction non exécutable qui sert à initialiser les variables par le com-pilateur, d'où économie de code et de temps par rapport à l'affectation pendant l'exécution d'un pro-gramme. La valeur affectée à une variable ou à un élément de variable indicée par cette instruction peut être modifiée par la suite en cours de programme.

data varlist1 / conslist1 / [ ,varlist2 / conslist2 / , . . .] avec : varlisti liste des identificateurs de variables simples ou de tableaux, éléments de tableaux ou

sous-chaînes de caractères, conslisti liste de constantes numériques, logiques ou chaînes de caractères, qui doit correspondre

en nombre, type et ordre à la liste des identificateurs qui la précède immédiatement. Les constantes sont séparées par la virgule et la liste est placée entre / ... / .

Si une variable est initialisée par l'instruction data dans un sous-programme subroutine ou function, variable qui voit sa valeur modifiée par la suite, il n'y a pas de réinitialisation par data lors d'appels ultérieurs du sous-programme. La valeur affectée par data n'est présente que lors de chaque activation de tout le programme. Si une variable de sous-programme doit être réinitialisée à chaque appel du sous-programme, il faut alors faire appel à la méthode usuelle, c'est-à-dire à l'affectation par = ou sauvegarder cette valeur. Chaque unité de programme peut comporter un nombre quelconque d'instructions data , la même variable ne pouvant évidemment figurer qu'une seule fois. Il est de tradition de placer les ins-tructions data après les déclarations des divers types, bien que ces instructions puissent se placer à n'importe quel endroit entre les éventuelles fonctions-formules et l'instruction end . Les listes conslisti peuvent contenir des variables indicées par des constantes. Un tableau sans indice représente tous les éléments dans l'ordre de rangement en mémoire. Lorsque plusieurs constantes consécutives sont égales, on peut l'indiquer par un facteur de répétition sous la forme : nombre * constante . Exemples :

real*4 table(10,4),x(8),y(8) character*18 titre

..... data table /40*1.0/ data x /0.2,0.4,0.5,0.8,1.0,1.2,1.4,1.6/ data y /2.0,1.0,0.0,1.0,2.0,3.0,4.0,5.0/ data titre /'Ecole d''Ingénieurs'/

La première instruction data affecte 40 fois 1.0 à tous les éléments de la variable indicée table (10,4). Les deux suivantes affectent des valeurs numériques aux deux vecteurs x (8) et y (8) et la dernière une chaîne de caractères à titre *18 . 3.1.3 AFFECTATION ARITHMÉTIQUE L'instruction d'affectation arithmétique assigne à la variable située à gauche du caractère = la valeur numérique de l'expression située à droite du caractère = . La syntaxe générale est :

var = expr avec : var une variable simple ou un élément de variable indicée, de type numérique, expr une expression arithmétique.

- 39 -


Le caractère = placé entre var et expr ne signifie pas du tout "égal à" au sens mathématique usuel, mais veut dire : affecte à la variable var la valeur de l'expression arithmétique expr . Pour que la variable var puisse être affectée correctement, il faut que tous les opérandes de l'ex-pression expr soient définis au moment de l'évaluation. Si la valeur de l'expression est du même type que la variable à affecter, l'instruction transmet immédiatement cette valeur. Par contre, si l'expression est d'un type différent comme c'est très souvent le cas, l'expression est tout d'abord calculée suivant les règles données précédemment, puis transformée ensuite dans le type de la variable à affecter et finalement transmise à var . La valeur de l'expression arithmétique doit pouvoir se représenter dans le type adopté pour var . Le tableau 3.1 donne les règles de transformation pour les types fondamentaux du langage.

Tableau 3.1 RÈGLES DE CONVERSION DANS L'AFFECTATION ARITHMÉTIQUE

Expression arithmétique E V variable

ou élément de tableau

integer ou logical

Real double precision

complex

integer ou

logical

Assigne E à V

Transforme E en entier et assigne à V

Transforme E en entier et assigne à V

Transforme PR de E en entier et affecte à V ; PI et E est perdue

real Génère la

fraction 0.0 dans E ;

assigne E à V

Assigne PPS de E à V ; DPS de V est des zéros

PPS de E est arrondie, DPS est perdue ; assigne E à V

Assigne PR de E

à V ; PI est perdue

Double Precision

Génère la partie 0.0 dans E ; DPS de V est des

zéros

Assigne PPS deE à V ;

DPS de V est des zéros

Assigne E à V

Assigne la partie réelle de E à V et complète par des zéros ; PI est perdue

complex

Génère la partie 0.0 dans E ;

Affecte à PR

Affecte E à laPR de V ; PI de V est égale à zéro

Affecte PPS de Eà V ; DPS est arrondie ; PI de V est perdue

Assigne E à V

Dans ce tableau, les lettres majuscules signifient :

PR partie réelle de la grandeur complexe, PI partie imaginaire de la grandeur complexe, PS partie significative, PPS première partie significative, DPS dernière partie significative, E expression arithmétique, V variable à affecter.

Exemples :

integer*2 index,j real*4 a,b,beta,c ..... beta = -1.0/(2.5*a*b**c+a*a) index = index+1

L'affectation d'une grandeur complexe à une variable ou à un élément de variable indicée de type complex fait intervenir les deux parties réelle et imaginaire, séparée par une virgule et encadrées de parenthèses.

- 40 -


Exemples :

complex*8 correc,rare ..... correc = (0.12324,5.56789) rare = (987.654,1.3579E4) 3.1.4 AFFECTATION LOGIQUE L'affectation logique évalue tout d'abord l'expression logique située à droite du caractère = et as-signe le résultat logique .true. ou .false. à la variable simple logique ou l'élément d'une variable indi-cée logique placé à gauche du caractère = . La syntaxe est :

varl = exprl avec : varl une variable ou un élément de tableau de type logical, exprl une expression logique. La variable ou l'élément de tableau, situé à gauche du caractère = doit être absolument de type logical . Tous les opérandes de l'expression logique doivent être définis avant l'évaluation logique. Exemples :

logical logi,lmax,lpage integer*2 job real*4 a,b,c ..... lpage = .true. logi = job .gt. 100 .and. .not. lpage lmax = (a .lt. b) .or. ((a .gt. b) .and. (a .le. c))

En complément de cette programmation, certaines paires de parenthèses ont été introduites dans le dernier exemple afin de faciliter la lecture des conditions logiques. 3.1.5 AFFECTATION D'UNE CHAÎNE DE CARACTÈRES L'instruction d'affectation alphanumérique assigne la valeur d'une expression de type character à une variable, à une sous-chaîne de caractères ou à un élément de tableau de type character . La syntaxe générale est :

vara = expra avec : vara une variable, un élément de tableau ou une sous-chaîne de type character, expra une expression de type character. Si la longueur de l'expression est plus grande que celle de la variable, l'expression est tronquée à droite. Si la longueur est plus courte que celle de la variable, l'expression est complétée par des blancs ou espaces à droite. L'expression doit être de type alphanumérique. Il n'est pas possible d'af-fecter une valeur numérique directement à une variable, un élément de tableau ou une sous-chaîne de type character sans effectuer une conversion de type. L'utilisation des sous-chaînes permet d'af-fecter une partie seulement de la chaîne complète. Exemples : Le premier exemple affecte les identificateurs des notes de la gamme et modifie la note « do » en « ut ». Le deuxième exemple enregistre toutes les lettres de l’alphabet en minuscules. Il modifie ensuite la suite par deux affectations successives.

- 41 -


*

* Exemple 2 * Affectation d'une chaîne de caractères * et modification de cette chaîne * program exem02 character*24 gamme * gamme = 'do re mi fa sol la si do' print *,'La gamme complète est : ',gamme gamme(1:2) = 'ut' gamme(23:24) = gamme(1:2) print *,'La nouvelle gamme est : ',gamme end

Résultat de l'exécution du programme : La gamme complète est : do re mi fa sol la si do La nouvelle gamme est : ut re mi fa sol la si ut

L'instruction print utilisée ici permet d'afficher des données à l'écran : constantes alphanumé-riques ou numériques, variables de types divers. L'affectation de caractères à une sous-chaîne, à partir de la même variable, s'effectue caractère après caractère. Si les deux termes à gauche et à droite de l'affectation traitent les mêmes caractères, il est certain qu'il y ait quelques problèmes de transmission correcte de ces caractères. L'exemple suivant montre précisément ce genre d'opération sur des sous-chaînes de la même variable. * * Exemple 3 * Affectation d'une chaîne de caractères * et modification partielle de la chaîne * program exem03 character*26 alfab * alfab = 'abcdefghijklmnopqrstuvwxyz' print *,'Alphabet initial : ',alfab alfab(7:10) = alfab(9:12) print *,'Alphabet modifié : ',alfab alfab(7:10) = alfab(6:9) print *,'Alphabet modifié : ',alfab end Résultat de l'exécution du programme

Alphabet initial : abcdefghijklmnopqrstuvwxyz Alphabet modifié : abcdefijklklmnopqrstuvwxyz Alphabet modifié : abcdeffiikklmnopqrstuvwxyz

Les modifications apportées portent sur les caractères numérotés 7 à 10 . La première modifica-tion s'effectue correctement tandis que la seconde provoque une duplication des caractères. 3.1.6 LECTURE DE DONNÉES Le but d'un programme est de pouvoir résoudre des problèmes généraux au moyen d'instructions du langage exprimant un ou plusieurs algorithmes. Ces instructions comprennent des spécifications de type, des initialisations implicites ou explicites des composantes comme les variables, de l'intro-duction d'un certain nombre de données variant d'un emploi à l'autre du programme, d'un certain

- 42 -


nombre d'opérations de calcul ou de modifications des données introduites, de l'affichage et/ou de l'impression des grandeurs de sortie, des ordres d'arrêt du programme. Les opérations d'entrée et de sortie (I/O) sont facilitées par quelques instructions de lecture et d'écriture simples. Le langage FORTRAN possède un certain nombre d'instructions très efficaces pour lire et afficher des résultats et des textes. Dans ce sous-chapitre, nous voulons présenter l'instruction read de lec-ture de données à partir du clavier. Le chapitre 5 traitera les possibilités étendues de l'instruction de lecture read et d'écriture write . L'instruction proposée ici permet d'entrer des valeurs numériques, logiques ou suite de caractères par un format dit libre. Lors d'une instruction de lecture, il faut se sou-venir des opérations effectuées par l'utilisateur et le compilateur FORTRAN : 1. frappe au clavier d'une suite de caractères, cette suite devant obéir à la syntaxe imposée par le

type de donnée, 2. après pression sur la touche de validation <RET> , traduction par le compilateur de la chaîne de

caractères en représentation interne de la donnée : - donnée numérique : type integer, real, double precision, complex

- donnée alphanumérique : chaque caractère est codé selon ASCII , les apostrophes d'enca-drement étant supprimés.

L'instruction de lecture des grandeurs d'entrée permet d'affecter des valeurs numériques ou des suites de caractères aux variables numériques et/ou aux variables de type character. Ces données sont frappées au clavier. La syntaxe de l'instruction élémentaire est :

read *, liste avec : * signifie unité de lecture par défaut : -----> actuellement le clavier. liste liste des variables spécifiant l'ordre d'affectation des valeurs numériques et/ou des chaînes

de caractères. Les variables sont séparées les unes des autres par la virgule. La liste peut contenir :

- un identificateur d'une variable, - une référence à un élément de variable indicée, - un identificateur de variable indicée, - une référence à une sous-chaîne de caractères, - une boucle do implicite contenant seulement les éléments cités ci-dessus. L'exécution de l'ordre read provoque la lecture des données frappées au clavier et leur affecta-tion successive aux entités citées dans la liste. Les valeurs entrées au clavier doivent être séparées les unes des autres par une virgule ou par un espace. Une chaîne de caractères doit être encadrée par des apostrophes, ce qui est très ennuyeux en pratique. Chaque constante introduite doit être du même type que la variable devant recevoir la donnée. Exemple :

integer annee character*10 mot,lot ..... read *,annee,mot,lot

A l'exécution de cette instruction de lecture, le programme attend l'introduction d'une constante entière qui sera affectée à la variable annee , deux chaînes de caractères qui seront transférées dans les variables mot et lot , chaque chaîne pouvant contenir jusqu'à 10 caractères. L'obligation de pla-cer des apostrophes en début et fin des chaînes de caractères est peu favorable à l'entrée simple des données. Il est possible de modifier légèrement l'instruction de lecture afin d'éviter cet inconvénient. Les données logiques doivent également s'introduire correctement en lecture. La syntaxe pour la lec-ture d'une donnée de type chaîne de caractères se transforme en :

read ( * , ' ( a ) ' ) varalfa avec : * signifie l'unité par défaut : -----> le clavier, a format pour donnée de type character, le nombre de caractères étant libre, varalfa une variable ou élément de variable indicée, sous-chaîne de type character.

- 43 -


Avec cette instruction, la chaîne de caractères peut s'écrire normalement, en oubliant la syntaxe des constantes de type character, c'est-à-dire sans les apostrophes d'encadrement. Si la donnée est de type logical , remplacez a par lc , c étant un entier positif fixant le nom-bre de caractères à lire. Dans ce cas, le premier caractère T ou t de la chaîne frappée au clavier affecte la valeur logique .true. à la variable logique de la liste, ou le premier caractère F ou f affecte la valeur logique .false. , les autres caractères n'ayant aucune signification. Exemple :

logical ljuste ..... read (*,'(l4)') ljuste

Recommandations : 1. Toute entrée de données au clavier sera accompagnée d'un texte apparaissant à l'écran citant les

valeurs à introduire et si nécessaire, leur type. 2. Le nombre de données à introduire par ligne sera limité à des valeurs de même type. Evitez de

proposer des données de types mélangés. 3. La meilleure des méthodes consiste à introduire une seule donnée par ligne avec affichage en

clair de la fonction de cette donnée. 3.1.7 AFFICHAGE DES DONNÉES ET DES TEXTES Pour pouvoir afficher des données, des textes et des résultats, le programme doit contenir une ou plusieurs instructions d'écriture. La syntaxe élémentaire de l'affichage à l'écran est :

print *, liste avec : * unité de sortie par défaut : -----> l'écran de l'utilisateur, liste une liste d'identificateurs de variables numériques ou alphanumériques, d'éléments de

variables indicées ou de constantes. La liste peut contenir des expressions quelconques, le plus souvent des variables de type quel-conque ou des chaînes de caractères. L'instruction permet l'affichage des données citées dans des zones successives d'une même ligne, ou plus si la ligne à afficher est trop longue. Chaque instruction print imprime une nouvelle ligne. Cette instruction est peu efficace et s'utilisera dans les affichages simples et les premiers exemples. Le chapitre 5 traite plus en détail l'instruction d'écriture write avec ses diverses possibilités. Exemple :

* * Exemple 4 * Lecture de deux valeurs réelles * Affichage de chaque valeur, de son quintuple et de son quart * program exem04 real*4 val1,val2 * print *,'Donnez deux valeurs réelles quelconques :' read *,val1,val2 * print * print *,'Résultat pour la première valeur :' print *,val1,5.0*val1,val1/4.0 print *,'Résultat pour la seconde valeur :' print *,val2,5.0*val2,val2/4.0 print * *

- 44 -


end Résultat de l'exécution du programme

Donnez deux valeurs réelles quelconques : 123.4567 987.65432 Résultat pour la première valeur : 123.4567000 617.2835000 30.8641800 Résultat pour la seconde valeur : 987.6543000 4938.2710000 246.9136000 3.1.8 INSTRUCTION : CONTINUE Cette instruction spécifie le transfert du déroulement du programme à la prochaine instruction exécutable suivant continue , dans le cheminement du programme. La syntaxe est simplement :

continue C'est une instruction exécutable, mais sans effet sur les données du programme. Elle s'utilise prin-cipalement comme instruction de fin de boucle do , même si la dernière instruction exécutable de la fin de boucle n'est pas une instruction prohibée par cette structure. Elle est alors accompagnée d'une étiquette. Exemple : do 10 i=1,10 a(i)=0.0 10 continue 3.1.9 INSTRUCTION : END L'instruction end indique la fin d'une unité de programme. Cette instruction sera la dernière instruction du texte source de chaque unité de programme. La syntaxe est :

end Dans le programme principal, cette instruction termine l'exécution du programme. Dans un sous-programme, l'instruction remplit deux fonctions : 1. fin de l'unité de programme, 2. correspond à l'instruction return . L'instruction end indique au compilateur la fin de la traduction en langage machine. 3.1.10 INSTRUCTIONS D'ARRET Deux instructions sont à disposition : pause pour un arrêt temporaire du programme et stop pour un arrêt définitif. 3.1.10.1 INSTRUCTION : PAUSE L'instruction pause interrompt temporairement l'exécution du programme afin de permettre quel-que action de la part de l'utilisateur et affiche un message à l'écran. La syntaxe est :

pause [ n ]

- 45 -


avec : n une constante de type character ou une constante entière de 0 à 99999. L'instruction provoque l'affichage d'un message au terminal, dépendant du compilateur, mais con-tenant en tout cas le mot pause . Si l'argument n est présent, il est affiché à l'écran. Pour poursuivre le programme, il suffit de presser sur la touche <RET> dans la plupart des implémentations. Le pro-gramme continue alors à l'instruction exécutable suivant immédiatement l'instruction pause. Exemple : Ce programme affiche des nombres entiers de 1 à une valeur choisie librement par l'utilisateur et calcule la racine carrée de ce nombre en introduisant les deux fonctions sqrt et float de la librairie FORTRAN . * * Exemple 5 * Ce programme calcule et affiche des nombres entiers * entre 1 et une valeur choisie par l'utilisateur * en bloc de 20 valeurs avec arrêt du programme * program exem05 intrinsic float,sqrt integer*4 i,icompt,inomb real*4 anomb,racine * icompt=0 * print *,'Donnez un nombre réel positif :' read *,anomb inomb = anomb * print * do 10 i=1,inomb racine = sqrt(float(i)) write (*,'(1x,a,i5,a,f10.5)') + 'La racine carrée de ',i,' est : ',racine icompt = icompt+1 if ((icompt .eq. 20) .and. (i .ne. inomb)) then print * pause 'Veuillez presser sur <RET>' print * icompt = 0 end if 10 continue * end Résultat de l'exécution du programme :

Donne99.9

z un nombre réel positif :

La racine carrée de 1 est : 1.00000 La racine carrée de 2 est : 1.41421 .......................................... La racine carrée de 20 est : 4.47214 Veuillez presser sur <RET> etc.

- 46 -


Dans cet exemple, l'écriture du texte s'effectue au moyen de l'instruction write accompagnée d'une mise en forme. Cette mise en forme est donnée par une constante chaîne de caractères dans laquelle : 1x saut du caractère de contrôle a texte alphanumérique i5 écriture d'une entité de type integer dans 5 colonnes f10.5 écriture d'une entité réelle dans 10 colonnes, virgule fixe, avec 5 décimales. 3.1.10.2 INSTRUCTION : STOP L'instruction stop s'utilise pour terminer l'exécution du programme avant l'exécution de la der-nière instruction exécutable de l'unité de programme en cours. La syntaxe est :

stop [ n ] avec : n une constante de type character ou une constante entière de 0 à 99999. Le programme s'arrête à l'exécution de cette instruction et affiche la constante si elle présente. Cette possibilité s'introduit très souvent dans le développement du programme afin de repérer l'endroit d'un arrêt d'exécution fautive. Il n'est pas recommandé d'utiliser cette instruction dans un programme définitif. Exemple :

real*4 a,b ..... read *,a,b if (a .lt. b) stop 'a est inférieur à b' b = b-1.0 if (a .eq. b) stop 'a est égal à b'

3.2 STRUCTURES SÉLECTIVES Les instructions d'un programme FORTRAN sont exécutées ligne après ligne. Il est souvent dési-rable de pouvoir rompre le déroulement séquentiel d'un programme au moyen d'ordres de contrôle. Il existe deux catégories d'ordres de contrôle : 1. Ruptures de séquence inconditionnelles, 2. Ruptures de séquence conditionnelles. Ces instructions nécessitent la présence d'étiquettes, entité que nous voulons si possible laisser de côté. Dans les exemples qui vont suivre et qui démontrent l'emploi de ces instructions, nous de-vrons introduire malheureusement des instructions avec étiquette. Il est possible de modifier ces structures afin de les adapter au style actuel de programmation, c'est-à-dire d'éviter des sauts intem-pestifs lors du déroulement du programme. 3.2.1 SAUTS INCONDITIONNELS Les ruptures inconditionnelles permettent de rompre le déroulement séquentiel du programme vers une ou plusieurs instructions étiquetées, suivant la valeur prise par une expression. La tendance actuelle consiste à éviter l'utilisation abusive de ces instructions en structurant différemment le programme. Il existe de nouvelles instructions introduites dans le langage Fortran 77. Le texte suivant décrit ces instructions afin de pouvoir comprendre les anciens textes « source Fortran ».

- 47 -


3.2.1.1 GO TO INCONDITIONNEL Cette instruction transfère l'exécution du programme vers l'instruction portant le numéro d'éti-quette spécifié. La syntaxe est :

go to etiq avec : etiq une constante entière, comprise entre 1 et 99999, correspondant à l'étiquette d'une instruction

exécutable dans la même unité de programme. Le déroulement du programme s'effectue de la ligne contenant l'instruction go to etiq à la ligne débutant par l'étiquette etiq . Cette instruction peut aussi s'écrire en un seul mot : goto . Exemples :

go to 55 ..... go to 875

Attention ! deux instructions go to ne peuvent pas se suivre dans l'unité de programme. Evitez cette instruction et contrôlez dans tous les cas que le saut inconditionnel n'engendre pas une boucle fermée sans issue de sortie. 3.2.1.2 GO TO IMPOSÉ Deux instructions au moins sont nécessaires pour former cette structure de saut : l'affectation d'un identificateur à une étiquette et l'instruction d'utilisation du saut. L'instruction assign relie une variable de type integer*4 avec une étiquette de la même unité de programme, permettant d'introduire un identificateur alphanumérique dans l'instruction go to plutôt qu'une étiquette numérique. La syntaxe est :

assign etiq to ivar avec : etiq une constante entière non signée correspondant à une étiquette d'une instruction exécutable

dans la même unité de programme, ivar l'identificateur d'une variable de type integer*4 . La variable ivar ne contient pas nécessai-

rement la valeur numérique de l'étiquette, mais l'adresse interne correspondante. La variable ivar ne peut pas s'introduire dans une expression arithmétique, car elle est indéfinie. Pour donner une valeur à cette variable, il faut utiliser une instruction d'affectation, l'adresse de l'éti-quette étant alors perdue. L'instruction go to imposé transfère le déroulement du programme vers l'instruction portant l'éti-quette assignée à la variable entière de l'instruction assign . La syntaxe est :

go to ivar [ [ , ] ( eliste ) ] avec : ivar une variable de type integer*4, eliste une liste d'une ou de plusieurs étiquettes d'instructions exécutables, séparées par la virgule,

placées entre parenthèses, dans la même unité de programme. Cette liste décorative n'a pas d'influence sur le déroulement du programme.

Exemple : * * Exemple 6 * Utilisation de trois instructions d'assignement d'identificateurs * d'étiquette et sauts dans le programme * program exem06 integer*4 erreur,fini,itexte,nombre *

- 48 -


assign 20 to itexte assign 30 to erreur assign 9999 to fini * 10 print * print *,'Introduisez :' print *,'- un nombre entier compris entre 1 et 100' read *,nombre * if ((nombre .lt. 1) .or. (nombre .gt. 100)) go to erreur * print *,'Merci pour votre participation !' go to fini * 20 format (i5,' n''est pas compris entre 1 et 100') 30 print itexte,nombre go to 10 * 9999 end

Résultat de l'exécution du programme : Introduisez : - un nombre entier compris entre 1 et 100 123 123 n'est pas compris entre 1 et 100 Introduisez : - un nombre entier compris entre 1 et 100 58 Merci pour votre participation ! 3.2.1.3 GO TO CALCULÉ L'instruction go to calculé transfère le déroulement du programme vers l'une des instructions à étiquette selon la valeur prise par une expression arithmétique de type integer. La syntaxe est :

go to ( etiq1 , etiq2 , . . . ) [ , ] iexpr avec : etiqi une étiquette d'une instruction exécutable dans la même unité de programme, la même

étiquette pouvant apparaître plusieurs fois dans liste. iexpr une expression arithmétique entière, donnant un résultant dans les limites 1 à n, si n est le

nombre d'étiquettes placées entre parenthèses. L'instruction go to calculé évalue la grandeur numérique de l'expression, et si nécessaire (seule-ment VAX-11), la transforme le résultat en type integer . Lorsque la valeur de l'expression est i , cette instruction transfère le déroulement du programme à la i ième étiquette de la liste. Si la valeur de l'expression est plus petite que 1 ou plus grande que le nombre d'étiquettes de la liste, le programme continue à la ligne suivant l'instruction go to calculé. Le principe de cette instruction peut se repré-senter par l'organigramme de la page suivante. Exemple : * * Exemple 7 * Introduction d'un nombre entier * Affichage si ce nombre est pair ou impair * program exem07

- 49 -


intrinsic mod integer*4 nombre,npair character*1 rep * 10 print * print *,'Entrez un nombre entier :' read *,nombre npair = mod(nombre,2) * go to (20,30) npair+1 * 20 print *,nombre,' est un nombre pair.' go to 40 30 print *,nombre,' est un nombre impair.' * 40 print * print *,'Encore un nombre (o/n) ?' read (*,'(a1)') rep if ((rep .eq. 'o') .or. (rep .eq. 'O')) go to 10 * end

Résultat de l'exécution du programme :

Entre1234

z un nombre entier :

1234 est un nombre pair. Encore un nombre (o/n) ? o Entre-123

z un nombre entier :

-123 est un nombre impair. Enn

core un nombre (o/n) ?

La fin d'une séquence d'instructions impose un saut dans le programme, action réalisée généra-lement par une instruction go to inconditionnel.

- 50 -


3.2.2 INSTRUCTION : IF . . . ARITHMÉTIQUE Cette instruction appartient aux instructions sélectives de transfert conditionnel du déroulement du programme. L'instruction if arithmétique transfère le déroulement du programme vers l'une des trois instructions à étiquette citées, suivant la valeur prise par l'expression arithmétique. La syntaxe de cette instruction est : if ( expr ) etiq1 , etiq2 , etiq3 avec : expr une expression arithmétique de type integer, real ou double precision, etiqi une étiquette d'une instruction exécutable dans la même unité de programme. Les trois étiquettes etiq1 , etiq2 , etiq3 doivent figurer dans cette instruction. Elles ne doivent pas nécessairement se rapporter à trois instructions différentes. L'expression entre parenthèses expr est tout d'abord évaluée et le déroulement du programme se poursuit en fonction de la valeur de l'expression arithmétique : 1. si expr est négative, l'exécution du programme se poursuit à l'instruction portant la première

étiquette etiq1 ; 2. si expr est nulle, l'exécution du programme se poursuit à l'instruction portant la seconde éti-

quette etiq2 ; 3. si expr est positive, l'exécution du programme se poursuit à l'instruction portant la troisième

étiquette etiq3 . Cette possibilité de diverger vers trois parties de programme différentes peut aussi s'effectuer au moyen du bloc if . . . sans faire intervenir des étiquettes, voir sous 3.2.4. La fonction de cette instruction peut se représenter sur l'organigramme partiel ci-après. Elle intro-duit toujours trois étiquettes et des sauts dans le programme.

Cette instruction se retrouvait fréquemment dans les sous-programmes mathématiques et ne de-vrait plus s'utiliser en programmation structurée. La configuration d'un programme partiel serait : if (iexpr) 10,20,30 10 { instructions de la séquence 1 si iexpr < 0 } go to 40 20 { instructions de la séquence 2 si iexpr = 0 } go to 40 30 { instructions de la séquence 3 si iexpr > 0 } 40 { suite des instructions du programme ... }

- 51 -


3.2.3 INSTRUCTION IF . . . LOGIQUE L'instruction if . . . logique provoque l'exécution conditionnelle d'une seule instruction FORTRAN. La syntaxe est :

IF ( lexpr ) instr avec : lexpr une expression de type logical , instr une instruction exécutable FORTRAN , sauf l'une des instructions suivantes : - boucle do , - end ou end do, - bloc if . . . , else if , else , end if , - une autre instruction if . . . logique. L'expression logique, placée entre parenthèses, est tout d'abord évaluée. Si la valeur de l'expres-sion logique est .true. , l'instruction instr est exécutée. Par contre, si l'expression logique est .false. , le programme continue à la ligne suivante sans exécution de l'instruction proposée. Cette instruction est à utiliser chaque fois que la structure sélective offre un seul choix possible. L'instruction ne comprend jamais le mot then . Exemples :

if (i .gt. 3) j = j+1 if (j .lt. 100) print *,'La valeur de j est inférieure à 100' 3.2.4 INSTRUCTIONS AVEC BLOC IF Les instructions se composant de un ou de plusieurs blocs if permettent de créer une ou plu-sieurs structures sélectives sans introduire des sauts et/ou des étiquettes. Les instructions compo-santes sont : - if . . . then - else if . . . then - else - end if Cet ensemble d'instructions représente une extension heureuse du if . . . logique et sera utilisé dans plusieurs exemples du cours. 3.2.4.1 CONFIGURATION GÉNÉRALE La combinaison des diverses composantes permet d'obtenir facilement le choix sélectif d'une sé-quence d'instructions. La forme générale de la structure est la suivante : if ( expr1 ) then bloc1 else if ( expr2 ) then bloc2 ..... else blocn end if

avec : expri une expression de type logical servant de sélecteur, bloci une suite de zéro à plusieurs instructions FORTRAN , cette séquence étant appelée bloc

d'instructions. L'instruction if ( expr1 ) then est toujours la première instruction d'un bloc. La séquence 1 d'ins-tructions est exécutée si la valeur de l'expression logique est .true. . L'instruction else if ( exprj )

- 52 -


then écrite sur une nouvelle ligne est une instruction complémentaire optionnelle. La séquence j qui suit cette instruction est exécutée si l'expression logique exprj prend la valeur .true. et si aucun bloc précédent n'a été exécuté. L'instruction else , placée seule sur une nouvelle ligne, est aussi une instruction optionnelle. La séquence suivant cette instruction est exécutée seulement si aucun autre bloc if le précédent n'a été exécuté. Aucune autre instruction if . . . ou bloc if ne peut suivre cette dernière séquence. La dernière instruction de la structure doit être : end if . Lorsque la dernière instruction d'un bloc est exécutée, le déroulement du programme continue à l'instruction suivant end if . En conséquence, un seul bloc if . . . est exécuté chaque fois. Le transfert d'exécution du programme de l'extérieur vers un bloc if , c'est-à-dire vers une instruc-tion étiquetée d'une séquence n'est pas autorisée. Nous voulons éviter toute utilisation d'étiquettes dans cette structure. La forme générale peut se décrire par la configuration suivante : if (a .gt. b) then séquence 1 else if (a .gt. c) then séquence 2 else if (a .gt. d) then séquence 3 else séquence 4 end if

L'écriture de cet exemple général montre le principe de la disposition des diverses séquences d'instructions. Il est vivement recommandé d'utiliser l'indentation dans l'écriture des instructions afin de faciliter la lecture et la compréhension du programme. 3.2.4.2 BLOC IF . . . SIMPLE Cette structure est une extension des possibilités de l'instruction if ... logique. Elle permet de trai-ter une séquence d'instructions si l'expression parenthésée prend la valeur logique .true. . if ( expr ) then séquence d'instructions end if

Il est possible de transférer le déroulement du programme à l'extérieur avant d'atteindre la derniè-re instruction de la séquence, mais pas de revenir dans le bloc. Evitez d'utiliser cette possibilité de saut. Si le bloc contient une boucle do ... , cette structure itérative doit se situer dans le même bloc if . . . . Exemple élémentaire : if (eps .ge. 1.0E-6) then total = total+eps valeur = valeur*total end if

Dans cet exemple de bloc simple, les deux instructions de la séquence sont exécutées seulement si eps est >= 0,000001 . Dans le cas contraire, les deux instructions d'affectation sont sautées à l'exécution. 3.2.4.3 BLOCS IF . . . ET ELSE Cette configuration résout la structure sélective suivante : si expression logique est vraie alors xécute la séquence 1 d'instructions e sinon exécute la séquence 2 d'instructions

- 53 -


La séquence 1 d'instructions comprend toutes les instructions comprises entre la ligne if ( expr ) then et la ligne contenant else . La séquence 2 d'instructions part après la ligne else et se termine avant la ligne de fin de bloc avec end if . Si l'expression expr prend la valeur logique .true. , la séquence 1 est exécutée, sinon c'est la séquence 2 qui est prise en compte. La configuration générale est : if ( expr ) then séquence 1 else séquence 2 end if

Cette structure permet d'effectuer un choix en fonction de la valeur prise par l'expression logique. 3.2.4.4 BLOCS IF . . . ET ELSE IF . . . Cette structure sélective représente un cas particulier du cas général et peut s'écrire : si expression 1 est vraie alors exécute la séquence 1 d'instructions sinon si expression 2 est vraie alors exécute la séquence 2 d'instructions sinon continue à l'instruction exécutable suivant end if

La configuration générale de cette structure se programme par : if (expr1) then séquence 1 else if (expr2) then séquence 2 end if 3.2.4.5 REMPLACEMENT DE L'INSTRUCTION : IF ARITHMÉTIQUE L'instruction if . . . arithmétique permet de bifurquer dans l'exécution du programme en fonction de la valeur arithmétique d'une expression. Nous pouvons remplacer cette structure à sauts et étiquettes par un ensemble de blocs if . if (iexpr .lt. 0) then séquence 1 else if (iexpr .eq. 0) then séquence 2 else séquence 3 end if

Dans cette programmation générale, iexpr représente une expression arithmétique de type inte-ger . Le test ( iexpr .eq. 0) ne présente pas de difficulté sur des valeurs entières. Par contre, si le test est effectué sur des entités réelles, l'égalité des représentations internes doit être satisfaite pour obtenir une valeur logique vraie. Dans les expressions logiques, la constante numé-rique doit s'écrire : 0 pour les types integer , 0.0 pour les types real .

3.2.4.6 STRUCTURE GÉNÉRALE Dans le cas de plus de deux blocs de programme, la configuration générale des instructions est donnée sur l'organigramme. La séquence 1 comprend toutes les instructions comprises entre if ... then et le premier else if ... then , la séquence 2 entre le premier else if ... then et le second else

- 54 -


if ... then , la séquence 3 entre le second else if ... then et else , la séquence 4 entre else et end if .

Remarque importante : Un seul bloc est évalué et comme l'instruction else est présente, le choix porte sur les tests suc-cessifs des expressions, sinon le programme se déroule dans la séquence 4 . 3.2.4.7 BLOCS IF . . . IMBRIQUÉS Un ensemble de blocs if ... peut être imbriqué dans un autre ensemble de blocs if ... . L'ensem-ble de blocs imbriqués doit être contenu dans un seul bloc if ... de niveau supérieur. Chaque ensem-ble doit se terminer par l'instruction end if . Le principe de cette structure imbriquée est donnée dans la configuration suivante : if (expr1) then séquence 1.1 if (expr12) then séquence 2.1 else séquence 2.2 end if else séquence 1.2 end if 3.2.5 EXEMPLE DE PROGRAMME Soit à résoudre l'équation algébrique du second degré au moyen de structures sélectives sans introduire une seule étiquette : a x2 + b x + c = 0 . La solution doit tenir compte de tous les cas possibles de solution : 1. équation du second degré si a # 0, racines réelles et complexes, 2. équation du premier degré si a = 0 et b # 0, 3. équation indéterminée si a = 0, b = 0 et c # 0. La solution de l'équation du second degré est obtenue en normant l'équation primitive par division par le coefficient a et en écrivant : X2 + 2 B X + C = 0 .

- 55 -


Ce programme introduit d'une façon systématique les blocs if ... et déclare toutes les variables utilisées. * * Exemple 8 * Equation du second degré : a x**2 + b x + c = 0 * Variables utilisées : * a,b,c coefficients et constante de l'équation primitive * bsur2a b divisé par 2 a * csura c divisé par a * discr discriminant : b**2-c * racine racine carrée du discriminant * * Fonctions arithmétiques : * sqrt racine carrée * abs valeur absolue * program exem08 intrinsic abs,sqrt real*4 a,b,c real*4 bsur2a,csura,discr,racine * print * print *,' EQUATION DU SECOND DEGRE' print *;' a x**2 + b x + c = 0 .' print * print *,'Donnez les coefficients et constante a,b,c' read *,a,b,c * * Bloc extérieur avec test de la valeur du coefficient a * if (a .ne. 0.0) then bsur2a=0.5*b/a csura=c/a discr=bsur2a**2-csura racine=sqrt(abs(discr)) * * Solution de l'équation du second degré * if (discr .gt. 0.0) then print *,'Deux racines réelles distinctes' print *,'x1 =',-bsur2a+racine print *,'x2 =',-bsur2a-racine else if (discr .eq. 0.0) then print *,'Deux racines réelles égales' print *,'x1 = x2 =',-bsur2a else print *,'Deux racines complexes conjuguées' print *,'x1 =',-bsur2a,' + j *',racine print *,'x2 =',-bsur2a,' - j *',racine end if * * Fin du premier ensemble des blocs intérieurs * Calcul de l'équation du premier degré * Nouvel ensemble de blocs intérieurs *

- 56 -


else if (b .ne. 0.0) then print *,'L''équation est du premier degre' print *,'x1 =',-c/b else print *,'L''équation est indeterminée' end if * * Fin du second ensemble intérieur * end if * * Fin de l'ensemble extérieur * Fin du programme * end Résultats de l'exécution du programme Exemple 1 :

EQUATION DU SECOND DEGRE a x**2 + b x + c = 0 . Donnez les coefficients et constante a,b,c 1 2 -3 Deux racines réelles distinctes x1 = 1.0000000 x2 = -3.0000000

Exemple 2 :

EQUATION DU SECOND DEGRE a x**2 + b x + c = 0 . Donnez les coefficients et constante a,b,c 1 2 3 Deux racines complexes conjuguées x1 = -1.0000000 + j * 1.4142140 x2 = -1.0000000 - j * 1.4142140

- 57 -


3.3 STRUCTURES ITÉRATIVES Le langage FORTRAN reconnaît deux structures itératives, la première avec un compteur d'ité-rations, la seconde, hors norme ANSI, mais très utile, de genre tant qu'une condition est remplie, exécute une séquence d'instructions. 3.3.1 STRUCTURE A COMPTEUR L'instruction do ... permet l'exécution d'une procédure répétitive d'une séquence d'instructions. Elle provoque le déroulement d'un ensemble d'actions programmées entre la définition du compteur et la fin de la boucle. 3.3.1.1 FORME FONDAMENTALE La formation d'une structure à répétition avec compteur se programme très facilement avec l'ins-truction do ... . La boucle est limitée par une instruction de définition, créant le compteur de boucle, et par une instruction de fin de boucle qui est soit une instruction à étiquette, soit pour les compilateurs admettant l'extension MIL-STD-1753, l'instruction end do . La syntaxe de création du compteur est :

do [ etiq [ , ] ] index = init , fini [ , pas ] avec : etiq une constante entière correspondant à l'étiquette d'une instruction exécutable, placée à la

suite de l'instruction do ... , dans la même unité de programme; index une variable servant de contrôle de la boucle, de type integer , real ou double precision; init une expression donnant la valeur initiale à la variable de contrôle index ; elle peut être une

constante ou une expression de type integer , real ou double precision ; fini une expression fixant la valeur finale pour la variable de contrôle index ; elle peut être une

constante ou une expression de type integer , real ou double precision ; pas une expression représentant l'incrément qui s'additionne après chaque parcours de la boucle

à la variable de contrôle index . Elle peut être une constante ou une expression de type integer , real ou double precision . L'incrément peut être positif, négatif mais pas nul. Si ce paramètre est absent, l'incrément vaut 1.

L'étiquette peut être omise si l'on utilise end do en fin de boucle. Dans les anciennes versions FORTRAN , les expressions de début, de fin et d'incrément ne pouvaient être que de type integer. La virgule après l'étiquette est optionnelle. La variable index est appelée variable de contrôle. Avant le déroulement de la séquence d'ins-tructions dans la boucle, les expressions sont évaluées et si nécessaire converties dans le type de la variable de contrôle. La fin de la structure est identifiée par une instruction à étiquette, l'instruction continue étant habituellement introduite dans ce but. L'instruction end do remplace avantageu-sement l'instruction étiquetée, si cette possibilité est comprise par le compilateur. L'instruction éti-quetée de fin de boucle ne peut pas contenir les instructions : - go to (inconditionnel ou assigné), - if (arithmétique ou bloc), - des instruction d'un bloc if : else if , else , end if , - end , - return , - une autre instruction do . Si le compilateur admet la version étendue, l'instruction terminale devient simplement :

end do L'ensemble des instructions, débutant par l'instruction do ... et se terminant par l'instruction à étiquette ou end do , fait partie de la structure de la boucle do .

- 58 -


3.3.1.2 CONTROLE DU NOMBRE D'ITÉRATIONS L'instruction do ... évalue tout d'abord les expressions init , fini et pas si c'est nécessaire. La valeur de l'expression init est alors affectée à la variable de contrôle index . Le nombre de fois que la boucle do est parcourue est calculable par :

[( fini - init + pas ) / pas ] cette expression étant réduite en entier et le résultat portant le nom de compteur d'itérations. Si le compteur d'itérations vaut zéro ou est négatif, la boucle n'est pas parcourue, contrairement aux ver-sions précédentes FORTRAN où elle était effectuée toujours au moins une fois. Après chaque parcours de la boucle do ... , les opérations suivantes sont effectuées : 1. la valeur de l'expression d'incrémentation est additionnée algébriquement à la variable de con-

trôle, 2. le compteur d'incrémentation est décrémenté de 1, 3. si la valeur du compteur d'itérations est supérieure à zéro, le programme continue à la première

instruction exécutable après l'instruction do , 4. si la valeur du compteur d'itérations est égale à zéro, l'exécution de la boucle do est terminée. Dans ce dernier cas, pour autant qu'il n'y ait pas de boucles imbriquées, le contrôle du déroule-ment du programme est transféré à la première instruction exécutable suivant directement l'instruc-tion terminale de la boucle do . Les valeurs de la variable de contrôle, de l'expression fini et de l'incrément ne doivent pas être modifiées à l'intérieur de la boucle do . L'erreur d'arrondi lors du calcul de l'incrément peut éventuel-lement fausser le nombre d'itérations de 1 . Si l'on désire un nombre bien déterminé de parcours, il est impératif de choisir une variable de boucle et des expressions de type integer . Exemples : avec étiquette avec end do do 10 nombre = 5,50,5 do nombre = 5,50,5 a(nombre)=a(nombre-1) a(nombre) = a(nombre-1) b(nombre-2)=b(nombre+2) b(nombre-2) = b(nombre+2) 10 continue end do La boucle proposée ici est parcourue : [(50-5+5)/5] = 10 fois. 3.3.1.3 BOUCLES IMBRIQUÉES Une structure itérative do peut contenir une ou plusieurs autres boucles do . Les boucles im-briquées peuvent avoir la même étiquette terminale avec l'instruction correspondante. Par contre, l'introduction de l'instruction end do nécessite une instruction terminale pour chaque boucle. Ce mode de programmation peut également s'introduire avec les instructions à étiquettes. Exemples de boucles imbriquées : avec 3 étiquettes avec end do do 30 I = 1,5 do i = 1,5 do 20 j = 1,5 do j = 1,5 v(i,j)=0.0 v(i,j)=0.0 do 10 k=1,5 do k=1,5) v(i,j)=v(i,j)+x(k,j) v(i,j)=v(i,j)+x(k,j) 10 continue end do 20 continue end do 30 continue end do

- 59 -


avec une seule étiquette do 10 i=1,5 do 10 j=1,5 v(i,j)=0.0 do 10 k=1,5 v(i,j)=v(i,j)+x(k,j) 10 continue Il est possible de sortir d'une boucle do par une instruction de rupture de séquence. Par contre, il est interdit d'entrer dans une boucle do par une autre instruction que celle contenant l'initialisation do Certains compilateurs (DOMAIN et VAX-11) lèvent cette interdiction et comprennent la version dite à boucle étendue. Il est alors possible de transférer le déroulement du programme vers l'extérieur de la boucle do , et, postérieurement de revenir dans la même boucle do . Dans ce cas, il est interdit d'uti-liser la variable de contrôle ou les expressions dans la partie extérieure de la boucle do . Ce mode de programmation est à éviter à moins de réutiliser une ancienne version d'un programme FORTRAN sans vouloir apporter de modifications. 3.3.1.4 EXEMPLE DE BOUCLES DO Cet exemple permet d'introduire une certaine quantité de nombres réels, jusqu'à 100 nombres, de les classer en ordre croissant et de calculer la moyenne arithmétique de ces nombres. * * Exemple 9 * Introduction de nombres réels, au maximum 100 nombres * Classement en ordre croissant et calcul de la moyenne * program exem09 integer*2 i,j,nombre real*4 prov,somme,valeur(100) * print * print *,'DETERMINATION D''UNE MOYENNE ARITHMETIQUE' print * print *,'Donnez la quantité de nombre à traiter (<=100)' read *,nombre * print * print *,'Introduisez des nombres réels quelconques' print * do i=1,nombre write (*,'(5x,a,i4,a,$)') 'Nombre numéro :',i,' = ' read *,valeur(i) end do * * Rangement en ordre croissant * do i=1,nombre-1 do j=i+1,nombre if (valeur(i) .gt. valeur(j)) then prov = valeur(i) valeur(i) = valeur(j) valeur(j) = prov end if end do

- 60 -


end do * * Calcul de la somme et de la moyenne, affichage des résultats * print * print *,'Valeurs rangées en ordre croissant' print * somme = 0.0 do i=1,nombre somme = somme + valeur(i) write (*,'(5x,a,i4,a,f12.4)') + 'Valeur classée numéro :',i,' = ',valeur(i) end do print * write (*,'(5x,a,f12.4)') 'Moyenne arithmétique :',somme/nombre * end Résultat de l'exécution du programme

DETERMINATION D'UNE MOYENNE ARITHMETIQUE

Donnez la quantité de nombre à traiter (<=100) 16

Introduisez des nombres réels quelconques

Nombre numéro : 1 = 21.2345

etc. Ecrivez ce programme et testez sa fonctionnalité. 3.3.1.5 BOUCLE DO IMPLICITE Cette structure, utilisée le plus souvent dans les instructions de lecture et d'écriture, est une simplification de la syntaxe fondamentale de la structure itérative, le mot-clé do étant omis. La description complète de cette possibilité est donnée sous 5.2.1 . Présentons un exemple d'affectation par l'instruction data et introduction d'une boucle implicite dans l'écriture du résultat.

* * Exemple 10 * Affectation d'un tableau par data * Utilisation de la boucle do implicite * program exem10 integer*2 i,j,mat(5,5) * data ((mat(i,j), j=1,1), i=1,5) /5*11/ data ((mat(i,j), j=2,2), i=1,5) /5*22/ data ((mat(i,j), j=3,3), i=1,5) /5*33/ data ((mat(i,j), j=4,4), i=1,5) /5*44/ data ((mat(i,j), j=5,5), i=1,5) /5*55/ * do i=1,5 print *,(mat(i,j), j=1,5) end do * end

- 61 -


Résultat de l'exécution du programme 11 22 33 44 55 11 22 33 44 55 11 22 33 44 55 11 22 33 44 55 11 22 33 44 55 Remarque : Dans le cas particulier, l'affectation par data s'effectue colonne après colonne. Il est aussi possible de simplifier l'affectation en programmant l'instruction suivante : data mat /5*11,5*22,5*33,5*44,5*55/ le résultat étant identique. 3.3.2 STRUCTURE TANT QUE L'instruction do while est une extension très utile de FORTRAN selon MIL-STD-1753. Elle contrôle l'exécution répétitive d'une série d'instructions. 3.3.2.1 INSTRUCTION : DO WHILE L'instruction do while est accessible par plusieurs compilateurs (DOMAIN et VAX-11). Elle contrôle l'exécution d'une séquence d'instructions tant que l'expression logique reste .true. . La syntaxe de cette instruction est :

do [etiq [ , ] ] while ( exprl ) avec : etiq une étiquette optionnelle d'une instruction exécutable dans la même unité de programme,

située après l'instruction de définition de la boucle. La virgule est optionnelle. Nous n'utili-serons pas cette possibilité de saut.

exprl une expression de type logical, placée entre parenthèses. Chaque boucle do while doit se terminer par sa propre instruction end do qui ne nécessite pas d'étiquette. Si end do est affectée d'une étiquette, celle-ci doit correspondre à celle citée dans do while . L'expression logique exprl est tout d'abord évaluée et testée à chaque départ de la boucle. Si l'expression est vraie, la séquence d'instructions entre do while et end do est effectuée. La boucle est parcourue tant que l'expression logique reste vraie. Si l'expression logique est fausse, la lecture des instructions de la boucle est terminée et le programme continue à l'instruction suivant end do . Cette instruction permet d'introduire plus facilement une programmation structurée. En définitive, les particularités de ces deux instructions sont : 1. la boucle est parcourue tant que l'expression exprl prend la valeur .true. lors de son évaluation; 2. si l'expression logique exprl prend la valeur .false. , la séquence d'instructions est sautée et le

programme se poursuit à la première instruction exécutable suivant end do ; 3. pour que cette structure fonctionne correctement, la séquence d'instructions doit comporter une

modification d'une ou de plusieurs entités apparaissant dans l'expression logique exprl ; 4. comme le test sur l'expression logique exprl s'effectue en premier, il est possible que la séquen-

ce d'instructions ne soit jamais effectuée. Les structures do while peuvent être imbriquées sans chevauchement des séquences d'instruc-tions. 3.3.2.2 EXEMPLE DE STRUCTURE DO WHILE Le programme proposé permet à l'utilisateur d'introduire un nombre entier positif et de calculer la somme de ces entiers et de leurs carrés.

- 62 -


* * Exemple 11 a * Introduction d'un nombre entier positif * Calcul de la somme des nombres et des carrés * program exem11 integer*4 carre,nombre,somme character*1 rep * data rep /'o'/ * do while ((rep .eq. 'o') .or. (rep .eq. 'O')) print * print *,'Donnez un nombre entier positif (<=500) :' read *,nombre somme = 0 carre = 0 do i=1,nombre somme = somme + i carre = carre + i*i end do print * print *,'La somme des entiers vaut :',somme print *,'La somme des carrés vaut : ',carre print * print *,'Encore une valeur (o/n) ?' read (*,'(a1)') rep end do * end Résultat de l'exécution du programme Donnez un nombre entier positif (<=500) : 100

La somme des entiers vaut : 5050 La somme des carrés vaut : 338350 Encore une valeur (o/n) ? n Si le compilateur n'admet pas cette structure itérative, il est possible d'obtenir le même résultat au moyen d'une structure sélective avec étiquette. Le même programme aurait alors les instructions suivantes: * * Exemple 11 b * (variante sans do while et end do) * Introduction d'un nombre entier positif * Calcul de la somme des nombres et des carrés * program exem11 integer*4 carre,nombre,somme logical*2 lcontr character*1 rep *

- 63 -


data rep /'o'/ lcontr = .true. * 10 if (lcontr) then print * print *,'Donnez un nombre entier positif (<=500) :' read *,nombre somme = 0 carre = 0 do 20 i=1,nombre somme = somme + i carre = carre + i*i 20 continue print * print *,'La somme des entiers vaut :',somme print *,'La somme des carrés vaut : ',carre print * print *,'Encore une valeur (o/n) ?' read (*,'(a1)') rep end if lcontr = (rep .eq. 'o') .or. (rep .eq. 'O') if (lcontr) go to 10 * end Pour simplifier les tests, ce programme introduit la variable lcontr de type logical*2 .

- 64 -

CHAPITRE 4

SOUS-PROGRAMMES FORTRAN-77 La technique actuelle de programmation consiste à décomposer la solution globale du problème informatique en un certain nombre de tâches spécifiques et élémentaires. La modularité des unités de programme est réalisée par l'utilisation de sous-programmes. Le langage FORTRAN se prête admi-rablement bien à cette méthode de travail. L'introduction d'un ou de plusieurs sous-programmes est efficace lorsque la même séquence d'instructions, éventuellement avec de légères variantes d'exécution, doit se réaliser en divers endroits d'un programme. De plus, la solution classique de problèmes typiques peut faire l'objet d'un sous-programme, unité qui s'intègre facilement dans les programmes chaque fois que ce type de problème est à résoudre. La subdivision d'un long programme en plusieurs unités, appelées à partir d'un programme principal par exemple sous forme d'un menu, présente l'avantage de n'exiger que la compilation des unités de programme modifiées, d'où gain de temps dans le développement.

La figure montre la configuration générale d'un programme comportant cinq tâches distinctes, atteintes à partir d'un menu principal, chaque tâche pouvant se décomposer en sous-tâches. En plus de cette organisation à divers niveaux, le programme comprend également des procédures utilisables dans chaque tâche comme par exemple les gestions d'écran ou des périphériques. Lors de l'appel d'un sous-programme, le déroulement du programme passe de l'instruction d'appel à l'unité du sous-programme, puis le contrôle d'exécution retourne à l'instruction d'appel s'il s'agit d'une fonction, ou à l'instruction qui suit l'instruction d'appel dans le cas d'une procédure. Le langage FORTRAN distingue les sous-programmes suivants : 1. fonctions de la librairie du langage; 2. les fonctions-formules dites uni-instructions, 3. les procédures de type subroutine; 4. les fonctions type function créées par le programmeur; 5. l'unité de déclaration block data. A cette collection de sous-programmes s'ajoute quelques instructions de gestion de la mémoire permettant le transfert des données.

- 65 -


4.1 LIBRAIRIE FORTRAN Le langage FORTRAN met à disposition des utilisateurs une librairie étendue de fonctions. Le ou les arguments figurant dans la liste peuvent être des constantes, des variables, des expressions et/ou des chaînes de caractères. Les paramètres sont placés entre parenthèses, séparés les uns des autres par la virgule. 4.1.1 IDENTIFICATEURS DES FONCTIONS Les fonctions de la librairie FORTRAN sont appelées fonction "intrinsic" . Ces fonctions sont écrites avec leur nom et leurs arguments dans des expressions. Lorsque la fonction est évaluée, le compilateur retourne une valeur qui est utilisée directement dans l'expression. 4.1.1.1 RÉFÉRENCE INTRINSIC En utilisation normale, l'identificateur d'une fonction de la librairie FORTRAN ne nécessite pas de déclaration particulière. Comme aucun nom réservé n'existe dans le langage et les déclarations des entités utilisées sont favorables à la compréhension du programme, il est possible de déclarer les fonctions de la librairie, avant leur utilisation, par l'instruction :

intrinsic fnom1 [ , fnom2 ] . . . avec : fnomi l'identificateur d'une fonction de la librairie FORTRAN . Chaque identificateur de fonction ne peut apparaître qu'une seule fois dans un instruction intrin-sic dans la même unité de programme, mais pas dans une instruction external . Tous les iden-tificateurs de fonction doivent appartenir à la librairie du langage. La déclaration d'une fonction de la librairie dans l'instruction intrinsic est obligatoire si cette fonction est passée comme paramètre. L'identificateur de la fonction est local dans l'unité de programme. Le type de la fonction ne peut pas être modifié par une instruction implicit , chaque fonction retournant une donnée de type déterminé. Les fonctions suivantes ne peuvent pas s'utiliser comme paramètre effectif dans la liste d'appel d'une procédure ou d'une fonction : amax0 dble idint lle max0 amax1 dmax1 ifix llt max1 amin0 dmin1 int log min0 amin1 float lge log10 min1 char ichar lgt max real complex sngl Comme il n'existe pas de mot réservé dans FORTRAN, l'identificateur d'une fonction écrite par le programmeur pourrait être le même que celui d'une fonction de la librairie et apparaître dans une instruction external . Il n'est pas recommandé de recourir à ce mode de programmation afin d'éviter toute confusion dans la création et la lecture d’un programme. 4.1.1.2 RÉFÉRENCE GENERIC Certains identificateurs de fonctions de la librairie sont désignés par fonction "generic" que nous pouvons nommer en français fonctions générales. Ces fonctions peuvent s'utiliser comme identi-ficateur général pour des arguments de types différents. Les identificateurs spécifiques présentent habituellement un préfixe qui dépend directement du type de ou des arguments ou du résultat. Les anciennes versions du langage ne connaissaient pas cette universalité dans la désignation des fonctions. Exemple :

- 66 -

4. Sous-programmes en Fortran 77 -

La fonction exponentielle possède l'identificateur général (generic) exp applicable aux types : real*4 , real*8 , complex*8 et complex*16 . Si l'on désire limiter le champ d'application de l'identi-ficateur à un type particulier, il faut alors programmer : exp(...) pour une expression de type real*4 dexp(...) pour une expression de type real*8 cexp(...) pour une expression de type complex*8 cdexp(...) pour une expression de type complex*16

4.1.2 DESCRIPTION DES FONCTIONS On distingue généralement deux catégories de fonctions : 1. Les fonctions utilitaires qui permettent de passer d'un type à l'autre, de prendre la valeur absolue

ou le signe d'une expression, de traiter les chaînes de caractères, etc. 2. Les fonctions mathématiques qui autorisent le calcul des fonctions courantes. Le résultat est

toujours de même type que celui du ou des arguments. Le type integer n'est pas employé dans ce genre de fonction.

La liste des fonctions de la librairie FORTRAN est donnée sous 4.1.3 . De légères variantes et des possibilités supplémentaires peuvent apparaître d'un compilateur à l'autre. La liste des fonctions distingue l'identificateur général (en anglais Generic name) de l'identificateur spécifique de la Fonc-tion (en anglais Specific name). L'utilisation de l'identificateur général, s'il existe pour la fonction, permet de programmer et d'effectuer les opérations prescrites par la fonction, indépendamment du type de l'expression servant d'argument. 4.1.2.1 FONCTIONS DE CONVERSION Les fonctions générales nommées ci-dessous sont de la forme : fonction(e ) avec e une expres-sion numérique quelconque (integer, real, double precision, complex) à convertir suivant la nature de la fonction. Ce sont : - conversion en entier : int ( e ) - conversion en réel : real ( e ) - conversion en double précision : dble ( e ) - conversion en complexe : cmplx ( e ) Exemples : int(3.14159) donne 3 real(100) donne 100.0 Dans ce dernier cas, la fonction spécifique pour convertir une donnée de type integer*2 ou inte-ger*4 en donnée real*4 serait float(100)). 4.1.2.2 CONVERSION ENTRE ENTIERS ET CARACTÈRES La fonction spécifique : char ( n ) donne le caractère ASCII de rang n et la fonction spécifique : ichar ( c ) donne le rang du caractère c du code ASCII. Exemples : char(65 donne A ichar(A) donne 65

- 67 -


4.1.2.3 FONCTIONS MATHÉMATIQUES ÉLÉMENTAIRES Sauf indications particulières, ces fonctions admettent une expression de type quelconque (integer, real, double precision) comme argument et retourne une valeur de même type. 1. Valeur absolue Retourne la valeur absolue de l'expression : abs ( e )

Exemple :

abs(-7.85) donne 7.85

Cette fonction s'applique également aux grandeurs de type complex . 2. Troncature Retourne dans la même précision que l'expression, la partie entière de l'expression real ou dou-ble precision : aint ( e ) Exemples : aint(4.278) donne 4.0 aint(-12.768) donne -12.0 3. Arrondi Arrondit l'expression de type real ou double precision en conservant l'entier le plus proche de même type : anint ( e ) Exemples : anint(4.98) donne 5.0 anint(-4.87) donne -5.0

L'arrondi peut aussi s'effectuer, avec transformation de type, sur des expressions de type real ou double precision, le résultat étant de type integer : nint ( e ) . Exemples : nint(3.897) donne 4 nint(7.345D01) donne 73 4. Reste de la division Retourne le reste de la division entière de a par b (modulo); cette fonction possède deux argu-ments qui peuvent être de type integer, real ou double precision : mod ( a , b ) avec b # 0 . Le calcul effectué est : a - int ( a / b ) * b . Exemples : mod(5,3) donne 2 mod(5.0,3.0) donne 2.0 Les deux arguments doivent être de même type. 5. Transfert de signe Retourne la valeur de a affectée du signe de b , soit : | a | si b > 0 ou encore -| a | si b < 0 : sign ( a , b ) . Exemples : sign(5,-2) donne -5 sign(5.0,-2.0) donne -5.0

- 68 -


Les deux arguments doivent être de même type : integer, real ou double precision, le résultat étant de même type que les arguments. 6. Différence positive Cette fonction retourne : a - b si a > b et 0 si a <= b : dim ( a , b ) Exemples : dim(9,4) donne 5 dim(7.0,9.0) donne 0.0

Les deux arguments doivent être de même type : integer, real ou double precision, le résultat étant de même type que les arguments. 7. Multiplication en double précision Retourne le produit de deux expressions de type real en type double precision : dprod ( a , b ) Exemple : dprod(4.0,6.5) donne 2.6D01 8. Valeur maximale ou minimale d'un ensemble de valeurs scalaires Ces fonctions retournent la valeur maximale : max ( e1 , e2 ,..., en ) des expressions ei ou la valeur minimale : min ( e1 , e2 ,..., en ) des expressions ei de la liste placée entre parenthèses. Toutes les expressions de la liste doivent être de même type : integer, real ou double precision. Exemples :

max(1.2,-9.897,5.876,12.4) donne 12.4 min(1.2,-9.897,5.876,12.4) donne -9.897

Les fonctions : amax(...) et amin(...) permettent de transformer une liste d'expressions de type integer en type real, les fonctions : max1(...) et min1(...) de transformer une liste d'expressions de type real en type integer, tout en choisissant la valeur maximale ou minimale. Dans ces doubles actions, les identificateurs max ou min ne peuvent plus s'utiliser. 4.1.2.4 FONCTIONS SUR DES EXPRESSIONS COMPLEXES La librairie FORTRAN possède quelques fonctions permettant de transformer des expressions de type complex . Ce sont : aimag ( e ) retourne la partie imaginaire en type real d'une expression de type complex . conjg ( e ) retourne la valeur complexe conjuguée de type complex d'une expression en

complexe. abs ( e ) retourne la valeur de type real du module de l'expression de type complex , soit : si eRe et eIm sont les parties réelles et imaginaires de l'expression primitive alors : abs (eRe,eIm) donne sqrt (eRe**2 + eIm**2) . Pour les expressions de type complex*16, voir les fonctions données dans la tableau 4.2. 4.1.2.5 FONCTIONS MATHÉMATIQUES GÉNÉRALES Les fonctions mathématiques proposées par la librairie FORTRAN permettent le calcul d'ex-pressions de type real ou double precision ou parfois de type complex , mais jamais de type integer. Elles retourne un résultat de même type. 1. Racine carrée Retourne la racine carrée de l'expression de type real, double precision ou complex : sqrt ( e ) avec e >= 0 ou complex .

- 69 -


Lorsque e est de type complex , sqrt ( e ) retourne la racine quand la partie réelle est plus grande que zéro ou, si cette dernière est nulle, la racine de la partie imaginaire si cette dernière est plus grande que zéro. Exemple : sqrt(25.0) donne 5.0 2. Fonction exponentielle Retourne l'exponentielle à la puissance e , où e est une expression de type real, double preci-sion ou complex : exp ( e ) Exemple : exp(1.0) donne 2.718282 3. Logarithme naturel Retourne la valeur du logarithme naturel de l'expression de type real, double precision ou com-plex : log ( e ) Exemple : log(1.0) donne 0.0

L'expression doit être positive et différente de zéro. Lorsque l'expression est de type complex , log ( exprcompl ) retourne la valeur principale, celle dont la partie imaginaire est inférieure à pi en module. 4. Logarithme décimal Retourne la valeur du logarithme décimal de l'expression de type real, ou double precision : log10 ( e ) Exemple : log10(10.0) donne 1.0

L'expression doit être positive et différente de zéro. 4.1.2.6 FONCTIONS TRIGONOMÉTRIQUES Les arguments de type real ou double precision des fonctions trigonométriques fondamentales sont exprimés en radians et non en degrés. VAX-11 permet exceptionnellement le calcul en degrés au moyen d'identificateurs particuliers. 1. Fonctions trigonométriques Les fonctions trigonométriques fondamentales à disposition sont sinus, cosinus et tangente. Ces fonctions utilisent des arguments de type real, double precision ou complex . Les identificateurs de ces fonctions sont : sin ( e ) pour le sinus de l'expression, cos ( e ) pour le cosinus de l'expression tan ( e ) pour la tangente de l'expression.

Exemples :

pi=3.141593 sin(0.5*pi) donne 1.0 cos(pi) donne -1.0 tan(0.25*pi) donne 1.0 2. Fonctions trigonométriques inverses Le résultat est donné en radians, les arguments pouvant être de type real ou double precision. Les identificateurs de ces fonctions sont :

- 70 -


asin ( e ) pour l’arcsinus de l'expression, acos ( e ) pour l'arccosinus, atan ( e ) pour l'arctangente atan2 ( e1 , e2 ) pour l'arctangente à deux arguments.

Cette dernière fonction est à préférer en programmation, car elle donne l'angle dans le quadrant correct, ce qui n'est pas le cas pour les autres fonctions. atan2 ( e1 , e2 ) correspond au calcul de l'arctangente de e1 sur e2 , l'expression e2 pouvant être nulle. Exemples : asin(1.0) donne 1.570796 acos(1.0) donne 0.0 atan(-1.0 donne -0.785398 atan2(1.0,-1.0) donne -0.785398

Les arguments doivent se situer dans les domaines normaux de définition des fonctions inverses. 4.1.2.7 FONCTIONS HYPERBOLIQUES Les arguments ou les résultats du calcul sont de type real ou double precision. 1. Fonctions hyperboliques Les fonctions hyperboliques à disposition sont : sinh ( e ) pour le sinus hyperbolique, cosh ( e ) pour le cosinus hyperbolique, tanh ( e ) pour la tangente hyperbolique de l'expression.

Exemples : sinh(1.0) donne 1.175201 cosh(1.0) donne 1.543081 tanh(1.0) donne 0.761594 2. Fonctions hyperboliques inverses Les fonctions hyperboliques inverses sont présentent seulement dans quelques compilateurs FORTRAN . Les arguments sont de type real ou double precision. Ces fonctions sont : asinh ( e ) pour l'argument sinus hyperbolique, acosh ( e ) pour l'argument cosinus hyperbolique, atanh ( e ) pour l'argument tangente hyperbolique.

Exemples :

asinh(1.0) donne 0.8813736 acosh(1.0) donne 0.0 atanh(0.5) donne 0.5493061 4.1.2.8 FONCTIONS DE MANIPULATION DE CHAÎNES La librairie FORTRAN contient seulement deux fonctions de manipulation de chaînes de carac-tères. Les possibilités offertes par les sous-chaînes de caractères remplacent bien des fonctions existant dans d'autres langages de programmation. 1. Longueur de la chaîne L'argument de cette fonction est de type character et le résultat de type integer . Cette fonction compte le nombre de caractères contenu dans la chaîne. L'identificateur de cette fonction est :

len ( chaine_de_caractères )

- 71 -


où chaine_de_caractères est une chaîne de type character. 2. Recherche d'une sous-chaîne dans une chaîne La fonction index ( ch1 , ch2 ) recherche la première occurence de la sous-chaîne ch2 dans la chaîne de caractères ch1 et retourne : - 0 si ch2 n'existe pas dans ch1 , - la position du premier caractère de ch1 où ch2 a été repéré. Le résultat est de type integer. Exemples :

index('Suisse','se') donne 5 index('Fribourg','bouge') donne 0 4.1.2.9 COMPARAISON LOGIQUE DE CHAÎNES Les fonctions citées permettent de comparer deux chaînes de caractères, ch1 et ch2, en imposant le code ASCII comme système de référence. Elles permettent d'éviter des erreurs de comparaison lorsque le code est différent, par exemple lors de l'utilisation du code EBCDIC (utilisé par IBM) . Ces fonctions sont : lge ( ch1 , ch2 ) correspond à ch1 .ge. ch2 lgt ( ch1 , ch2 ) correspond à ch1 .gt. ch2 lle ( ch1 , ch2 ) correspond à ch1 .le. ch2 llt ( ch1 , ch2 ) correspond à ch1 .lt. ch2

Le résultat de l'évaluation de la fonction est de type logical : .true. ou .false. . 4.1.3 TABLE DES FONCTIONS DE LA LIBRAIRIE FORTRAN Les tables ci-après comprennent les fonctions de la librairie FORTRAN en citant leurs buts, le nombre d'arguments à placer entre parenthèses, le nom général et/ou le nom spécifique, le type des arguments et du résultat. Les identificateurs généraux et spécifiques sont écrits en caractères gras, sauf les identificateurs hors norme ANSI . Le sous-chapitre 4.1.2 donne une description plus complète des fonctions principales et des exemples.

- 72 -


Tableau 4.1 FONCTIONS UTILITAIRES GÉNÉRALES : CONVERSION ET CHOIX

But de la Nombre Nom Nom Type des Type du fonction d'arguments generic spécifique arguments résultat

Valeur 1 int int tous integer entière ifix real*4 integer idint real*8 integer Valeur 1 real real tous real*4 réelle float integer real*4 . sngl real*8 real*4

Valeur double 1 dble dble tous real*8 precision dfloat integer real*8

Valeur 1 ou 2 cmplx cmplx tous complex*8 complexe dcmplx dcmplx tous complex*16

Valeur 1 abs abs tous même type absolue iabs integer integer . dabs real*8 real*8 . cabs complex*8 real*4 . cdabs complex*16 real*8

Troncature 1 aint aint real*4 real*4 . dint real*8 real*8

Arrondi 1 anint anint real*4 real*4 en réel dnint real*8 real*8

Arrondi à 1 nint real*4 integer l'entier idnint real*8 integer

Reste de 2 mod mod integer integer la division amod real*4 real*4 . dmod real*8 real*8

Transfert 2 sign isign integer integer de signe sign real*4 real*4 . dsign real*8 real*8

Différence 2 dim idim integer integer positive dim real*4 real*4 . ddim real*8 real*8

Multiplication 2 dprod real*4 real*8 en real*8

Valeur n max max0 integer integer maximale amax0 integer real*4 amax1 real*4 real*4 max1 real*4 integer dmax1 real*8 real*8

Valeur n min min0 integer integer minimale amin0 integer real*4 amin1 real*4 real*4 min1 real*4 integer dmin1 real*8 real*8

tous -----> type integer , real ou complex

- 73 -


Tableau 4.2 FONCTIONS SUR LES EXPRESSIONS COMPLEXES


Partie 1 real complex*8 real*4 réelle dreal complex*16 real*8

Partie 1 aimag complex*8 real*4 imaginaire dimag complex*16 complex*16

Complexe 1 conjg conjg complex*8 complex*8 conjugué dconjg complex*16 complex*16

Tableau 4.3 FONCTIONS MATHÉMATIQUES GÉNÉRALES


Racine 1 sqrt sqrt real*4 real*4 carrée dsqrt real*8 real*8 csqrt complex*8 complex*8 cdsqrt complex*16 complex*16

Logarithme 1 log alog real*4 real*4 naturel ln(a) dlog real*8 real*8 clog complex*8 complex*8 cdlog complex*16 complex*16

Logarithme 1 log10 alog10 real*4 real*4 décimal log(a) dlog10 real*8 real*8

Exponentielle 1 exp exp real*4 real*4 e**x dexp real*8 real*8 cexp complex*8 complex*8 cdexp complex*16 complex*16

Tableau 4.4

FONCTIONS TRIGONOMÉTRIQUES ET HYPERBOLIQUES


1. Fonctions trigonométriques

Sinus 1 sin sin real*4 real*4 dsin real*8 real*8 csin complex*8 complex*8 cdsin complex*8 complex*8

Cosinus 1 cos cos real*4 real*4 dcos real*8 real*8 ccos complex*8 complex*8 cdcos complex*16 complex*16

- 74 -


Tableau 4.4 (suite) FONCTIONS TRIGONOMÉTRIQUES ET HYPERBOLIQUES


1. Fonctions trigonométriques (suite)

Tangente 1 tan tan real*4 real*4 dtan real*8 real*8

Arc sinus 1 asin asin real*4 real*4 dasin real*8 real*8

Arc cosinus 1 acos acos real*4 real*4 dacos real*8 real*8

Arc tangente 1 atan atan real*4 real*4 datan real*8 real*8

2. Fonctions hyperboliques

Sinus 1 sinh sinh real*4 real*4 hyperbolique dsinh real*8 real*8

Cosinus 1 cosh cosh real*4 real*4 hyperbolique dcosh real*8 real*8

Tangente 1 tanh tanh real*4 real*4 hyperbolique dtanh real*8 real*8

Tableau 4.5 FONCTIONS COMPLÉMENTAIRES


1. Comparaison logique de chaînes

supérieur égal 2 lge character logical supérieur 2 lgt character logical inférieur égal 2 lle character logical inférieur 2 llt character logical

2. Manipulation de chaînes ou de caractères

longueur 1 len character integer position 2 index character integer caractère 1 char integer character valeur ASCII 1 ichar character integer

3. Manipulation de bits (hors norme ANSI, voir manuels)

OU 2 ior integer integer

ET 2 iand integer integer OU exclusif 2 ieor integer integer décalage 2 ishft integer integer effaçage 2 ibclr integer integer test de bits 2 btest integer logical

- 75 -


4.2 LISTES DE PARAMÈTRES Tout programme FORTRAN se compose au moins d'une unité de programme constituée par le programme principal et optionnellement d'unités supplémentaires sous forme de sous-programmes : subroutine , function ou block data . Chaque unité de programme peut se compiler séparément sans tenir compte de sa position définitive dans le programme exécutable. La liaison entre les diver-ses unités de programme est réalisée soit par l'intermédiaire des listes de paramètres, nommés aussi arguments, soit par des définitions de zones communes de stockage des données en mémoire. Les sous-programmes FORTRAN ne sont pas récursifs, c'est-à-dire qu'ils ne peuvent pas s'appe-ler eux-même, ni directement, ni indirectement. Le sous-programme ne devient actif qu'au moment de son appel à partir d'une autre unité de programme. Comme les sous-programmes généraux de type subroutine ou function sont écrits une fois pour toute, les identificateurs des variables utilisées dans ces procédures et fonctions ne sont pas nécessairement les mêmes que ceux de l'unité de program-me appelante. Les données sont transférées de l'unité d'appel vers le sous-programme et vice versa selon des règles strictes traitées dans ce sous-chapitre. Toute unité de programme commence à la première instruction exécutable et tout programme débute à la première instruction exécutable du pro-gramme principal, cette unité pouvant comporter une instruction program .

4.2.1 PARAMÈTRES FORMELS ET EFFECTIFS Les paramètres transmettant des données de l'instruction d'appel vers le sous-programme sont nommés paramètres d'entrée dans la procédure ou fonction, les données transmises par la procédure ou la fonction vers l'instruction d'appel sont dénommés paramètres de sortie de la routine. Enfin, les paramètres peuvent être mixtes, c'est-à-dire servir à la transmission de données dans les deux sens de l'appel vers le sous-programme et du sous-programme vers l'appel. Les listes de l'instruction d'ap-pel et celle de définition du sous-programme peuvent contenir ces trois catégories de paramètres dans n'importe quel ordre. En exprimant les paramètres effectifs par les sigles suivants : pee paramètre d'entrée pes paramètre de sortie pem paramètre mixte et les paramètres formels par les sigles : pfe paramètre d'entrée pfs paramètre de sortie pfm paramètre mixte la transmission de données entre les deux listes peut se représenter dans le schéma suivant con-tenant chaque fois deux paramètres de chaque catégorie citée : liste d'appel ( pee1 , pee2 , pes3 , pes4 , pem5 , pem6 ) | | | | | | | | | | | | | | | | | | liste du S.P. ( pfe1 , pfe2 , pfs3 , pfs4 , pfm5 , pfm6 )

° ° ° ° ° °

4.2.1.1 PARAMÈTRES EFFECTIFS Les paramètres dits effectifs figurent dans l'instruction d'appel du sous-programme : subroutine ou function . Ils peuvent être : - des constantes, - des variables simples, - des expressions de type numérique, character ou logical, - des variables de tableaux, - des éléments de variable indicée, - des sous-chaînes de caractères,

- 76 -


- des identificateurs de sous-programmes. Tout identificateur de sous-programme spécifié dans la liste des paramètres effectifs doit figurer obligatoirement dans une instruction external dans la même unité de programme. La syntaxe de cette instruction de spécification est :

external idensp1 [ , identsp2 ] . . . avec : idensp1 identificateur d'un sous-programme externe écrit par le programmeur : subroutine ou

function. L'identificateur ne peut être cité qu'une seule fois dans une instruction external dans l'unité de programme et ne peut pas figurer dans une instruction intrinsic .

L'instruction external est introduite pour spécifier qu'un identificateur de procédure ou de fonction peut s'introduire comme paramètre procédural dans la liste des paramètres effectifs. Le compilateur range chacun de ces identificateurs dans un emplacement de la mémoire où ils seront retrouvés lors de l'assemblage des diverses unités. Cette instruction permet également de déclarer les autres iden-tificateurs de sous-programmes externes dans la partie spécification. Les fonctions-formules ne doivent pas se placer dans cette instruction. Si un nom de fonction "intrinsic" est cité dans cette liste, la fonction de la librairie FORTRAN n'est plus accessible (méthode de programmation à éviter abso-lument). La liste des paramètres effectifs comprend des paramètres classés sous la désignation d'entrée, de sortie ou mixtes. Les constantes et les expressions, citées ci-dessus, ne peuvent être que des paramètres d'entrée dans les sous-programmes. Exemple d'utilisation de l'instruction external

* programme principal subroutine calc (x,f,y) program princi y = 2.0*f(x)-4.0 ..... end external calc,fonc1,fonc2 ..... real function fonc1(z) call calc (phi1,fonc1,res1) ..... ..... end call calc (phi1,fonc2,res2) ..... real function fonc2(z) call calc (phi2,fonc1,res3) ..... ..... end end

Dans l'unité de programme principal, la première instruction call ... transfère le nom de la fonc-tion fonc1 au sous-programme calc (...) . La fonction fonc1 , déclarée comme fonction externe, est transférée à la seconde ligne du sous-programme par la référence f ( x ) qui est finalement utilisée dans l'évaluation de l'expression, puis affectée à y . Dans le second appel, c'est la fonction fonc2 qui est évaluée dans le même sous-programme calc (...) et dans le troisième appel, c'est à nouveau la fonction fonc1 qui intervient dans l'évaluation. En l'absence d'une instruction de déclaration external , le compilateur ne pourrait pas reconnaître l'identificateur comme nom d'un sous-programme et admettrait simplement que l'identificateur cité dans la liste est par exemple celui d'une variable simple. 4.2.1.2 PARAMÈTRES FORMELS Les paramètres formels figurent dans la liste accompagnant l'instruction de définition du sous-programme : fonction-formule, subroutine ou function. Ils portent la désignation formel car ils interviennent dans les diverses expressions des instructions du sous-programme. Les paramètres dits d'entrée reçoivent des données par l'intermédiaire des paramètres effectifs de l'instruction d'appel et les paramètres dits de sortie ou mixtes transmettent leurs données à ceux de la liste des paramètres effectifs. Du mécanisme de la transmission des données, il devient évident que les paramètres for-mels ne peuvent pas être des constantes ou des expressions. De plus, un paramètre formel, relié à un

- 77 -


paramètre effectif constitué par une constante ou une expression, ne peut pas subir de modification dans le sous-programme. Les paramètres formels correspondent un peu aux variables utilisées dans un formulaire mathé-matique. A l'emploi du formulaire, il faut remplacer les variables du formulaire par les valeurs numéri-ques du problème à résoudre. Les paramètres formels peuvent représenter : - des variables simples, - des variables de tableaux, - des identificateurs de sous-programmes. Chaque identificateur de paramètre formel doit rester unique dans la liste. Un paramètre formel, déclaré comme variable de tableau dans le sous-programme, ne peut se relier qu'à un paramètre effectif qui est aussi un tableau d'éléments de même type. Ce paramètre formel ne peut pas contenir plus d'éléments que le nombre d'éléments déclarés pour le paramètre effectif. Par contre, il peut se déclarer à dimensions ajustables. La longueur d'un paramètre formel de type character ne peut pas être plus grande que la lon-gueur du paramètre effectif qui lui est associé. Si la longueur du paramètre formel est déclarée par *(*) , les deux longueurs sont alors égales. Les paramètres formels ne peuvent pas figurer dans une instruction equivalence . 4.2.2 CORRESPONDANCE ENTRE LES LISTES A chaque paramètre effectif de la liste d'appel doit correspondre un paramètre formel de même type dans la liste du sous-programme, mais pas nécessairement de même identificateur. La corres-pondance s'effectue par adresse (ou référence) de la place mémoire de l'entité à transmettre. Pour concrétiser cette règle générale de correspondance entre les listes des paramètres effectifs et formels, supposons que les unités contenant les instructions d'appel et les sous-programmes con-tiennent les déclarations suivantes :

* * Type des variables simples utilisées dans les unités : * implicit real*4 (a-h,o-y) implicit integer*2 (i-n) implicit complex*8 (z) Donnons quelques listes d'appel et de sous-programmes en indiquant, si c'est nécessaire, les erreurs éventuelles. Liste d'appel Liste du sous-programme Erreur éventuelle

(b,c,mod(i,7)) (b,y,nana) aucune (a,b,c) (a,p) nombre différent (a,ifix(d)) (c,mon) aucune (d,e) (c,k) pas de même type (d,4.0) (h,zap) pas de même type

(d,(4.0,3.0)) (b,zip) aucune (a(10),c) (b,8.0) constante interdite (d,c,d) (a,d,a) deux fois paramètre a (f,c,f) (a,b,c) aucune (i,j,k) (n1,n2,n3) aucune Une des difficultés majeures de la programmation en FORTRAN est le passage des variables de tableaux ou des chaînes de caractères entre les deux listes. Il faut se souvenir que la transmission des données doit s'effectuer de telle sorte que le même élément ait la même adresse interne dans les deux unités de programme, le compilateur ne pouvant en aucun cas deviner cette position en mé-moire.

- 78 -


4.2.3 TRANSMISSION DES VARIABLES DE TABLEAUX Plusieurs règles s'appliquent à la transmission des données entre la liste d'appel contenant les paramètres effectifs et la liste de réception du sous-programme avec ses paramètres formels. Si la donnée est une entité simple à nombre d'octets fixe, il suffit que les paramètres soient de même type. Lorsque le paramètre effectif est une constante numérique entière, cette constante est stockée dans 4 octets quelle que soit sa valeur, à moins qu'une directive de compilation impose integer*2 par défaut. 4.2.3.1 DIMENSIONS DES VARIABLES INDICÉES Le but d'un programme complet et de ses sous-programmes est de résoudre une tâche parti-culière quelle que soit les dimensions réellement utilisées pour les variables de tableaux. Un para-mètre formel déclaré comme variable de tableau ne peut être associé qu'avec un paramètre effectif correspondant à une variable indicée ou à un ensemble d'éléments de tableau de même type. Le nombre d'éléments du paramètre formel doit rester inférieur ou, à la limite, égal au nombre d'éléments du paramètre effectif. Si l'élément effectif est un élément de tableau, cet élément et les éléments suivants sont associés aux éléments correspondants du paramètre formel indicé par adresse. Le nombre total d'éléments transféré entre les deux listes dépend de la dimension spécifiée pour le paramètre formel. Le langage FORTRAN reconnaît une variable de tableau au niveau de la déclaration et dans son utilisation dans les instructions. Les dimensions données dans la spécification servent seulement à calculer la position de l'élément dans la place mémoire attribuée à la variable indicée. Il en résulte que le nombre total de place mémoire pour les éléments et leurs positions dans la mémoire sont plus importants que les grandeurs attribuées à chaque dimension dans les déclarations. Donnons un premier exemple de programme partiel utilisant un dimensionnement numérique dans le sous-programme. * * * Programme correct * Programme incorrect * * program princ1 program princ2 real*4 a(10),b(5,5) real*4 a(10),b(5,5) ..... ..... call soupr1 (a,b(1,2)) call soupr2 (a,b(1,2)) end end subroutine soupr1 (x,y) subroutine soupr2 (x,y) real*4 x(10),y(5,5) real*4 x(12),y(5,5) ..... ..... end end Dans le second exemple, la dimension de la variable indicée x , associée à la variable a du programme principal, prévoit 12 éléments dans le sous-programme alors que le nombre d'éléments prévus pour a n'est que de 10 ! Les deux sous-programmes proposés spécifient des dimensions fixes sous forme de constantes entières pour les deux variables indicées, d'où perte d'universalité de ces sous-programmes ! Le dimensionnement d'un vecteur ou d'un tableau, au niveau inférieur comme ici dans le sous-programme, ne nécessite pas de places mémoire supplémentaires pour les variables indicées. 4.2.3.2 DIMENSIONS AJUSTABLES Un sous-programme doit permettre de traiter des variables indicées de dimensions quelconques, dépendantes des paramètres effectifs et non d'un dimensionnement fixe dans le sous-programme. Par exemple, le produit matriciel de deux tableaux numériques, programmé dans une procédure subroutine , doit pouvoir effectuer cette opération dans tous les cas, quel que soit le nombre de

- 79 -


lignes et de colonnes des tableaux. Un dimensionnement fixe dans le sous-programme ne permettrait pas une manipulation aisée des éléments des tableaux, car ces éléments seraient rangés en mémoire selon les règles exposées précédemment, des zéros venant s'intercaler entre les éléments introduits. La déclaration de la dimension d'une variable indicée, servant de paramètre formel, contient une ou plusieurs dimensions imposées par une ou plusieurs variables de type integer . Cette syntaxe porte le nom de dimensionnement ajustable. La déclaration de la ou des dimensions ajustables d'une variable de tableau dans un sous-pro-gramme obéit aux règles suivantes : 1. la variable de tableau doit être un paramètre formel; 2. la variable de tableau ajustable doit être associée avec un paramètre effectif qui est une variable

indicée de même type; 3. le nombre d'éléments de la variable de tableau ajustable doit rester inférieur ou égal au nombre

d'éléments transmissibles par le paramètre effectif; 4. les variables de type integer servant de dimensionnement de la variable ajustable doivent figurer

dans la liste des paramètres formels et les paramètres effectifs correspondant doivent être définis à l'appel du sous-programme;

5. La variable de tableau servant de paramètre effectif doit posséder des dimensions connues à l'exécution du passage des paramètres;

6. Les dimensions de la variable ajustable peuvent être transmises par une instruction de zone commune. Dans ce cas, les dimensions doivent être connues avant l'appel du sous-programme;

7. Une variable servant de dimension dans la liste des paramètres formels ne doit pas subir de modification après son utilisation comme spécificateur de dimension. C'est donc uniquement un paramètre d'entrée.

Exemple : Ce programme montre l'affectation de 2 tableaux à choix par une procédure genere et l'appel d'une fonction qui calcule la somme des éléments placés dans les tableaux. * * Exemple 12 * Somme des valeurs des éléments de deux tableaux * Ce programme utilise 2 sous-programmes : genere et somme * program exem12 integer i,m,n real*4 a(50,50),b(50,50),somtot character tablo*1,forme*30 external genere,somme * data forme /'(//,10x,a,//,5(5x,10f7.2,/))'/ * do i=1,4 write (*,'(//,20x,a,//,5x,a,\)') + 'SOMME DES ELEMENTS D''UN TABLEAU', + 'Donnez le nom du tableau (a ou b) ' read (*,'(a1)') tablo write (*,'(12x,a,\)') 'les dimensions ligne, colonne (<=50) ' read *, m,n if (tablo .eq. 'a') then call genere (a,m,n) somtot=somme(a,m*n) else call genere (b,m,n) somtot=somme(b,m*n) endif write (*,'(/,5x,a,a1,a,f15.2,/)')

- 80 -


+ 'La somme des éléments du tableau ',tablo,' vaut : ',somtot end do * write (*,forme) 'Affichage de tous les éléments du tableau a', + ((a(i,j),j=1,50),i=1,50) write (*,forme) 'Affichage de tous les éléments du tableau b', + ((b(i,j),j=1,50),i=1,50) end * ************************************ * * Procédure affectant les éléments * subroutine genere (d,m,n) integer i,j,m,n real*4 d(m,n) * do i=1,m do j=1,n d(i,j)=i+j/100.0 end do end do * end * ************************************ * * Fonction générant et calculant la somme des éléments * real function somme (e,n) integer i,n real*4 e(n) * somme=0.0 do i=1,n somme=somme+e(i) end do * end Résultat de l'exécution du programme

SOMME DES ELEMENTS D'UN TABLEAU

Donnez le nom du tableau (a ou b) : a les dimensions lignes, colonnes (<=50) 20 20

La somme des éléments du tableau a vaut : 4241.99

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

Affichage de tous les éléments du tableau a 1.01 11.03 1.06 11.08 1.11 11.13 1.16 11.18 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 .................... etc.

- 81 -


Dans cet exemple, les éléments des deux variables indicées a et b sont définis dans la procé-dure genere (...) . Les valeurs réelles stockées dans les éléments sont des entiers correspondant au numéro de ligne, des centièmes correspondant au numéro de colonne, séparées par le point décimal. Les éléments sont placés dans des places de mémoire contiguës, les indices dans les sous-pro-gramme ne correspondant pas aux indices du programme principal. La fonction somme (...) travaille sur un vecteur de dimensions m * n et non sur un tableau. Le programme principal est au niveau supérieur, les deux sous-programmes au même niveau inférieur. La transmission des données s'effectue par adresse et non par valeur. Le programme prévoit encore l'affichage des deux tableaux, ligne après ligne, a (50,50) et b (50,50) dans le pro-gramme principal afin de mettre en évidence la position des éléments dans ces tableaux complets. L'affichage ci-dessus ne concerne qu'une très petite partie de l'affichage complet des 2500 éléments des deux tableaux. 4.2.3.3 STOCKAGE DES DONNÉES Le programme principal ou l'unité de programme au niveau supérieur doit contenir le dimension-nement numérique et maximal des variables de tableaux et les sous-programmes un dimension-nement ajustable des tableaux utilisés à ce niveau inférieur. Pour que la transmission des données s'effectue correctement, il faut que la programmation des indices permette de retrouver toujours le même élément en mémoire vive. 1. Stockage des éléments d'un vecteur Les éléments d'un vecteur ou variable indicée à une dimension sont repérés par un seul indice. Si le premier élément est repéré par l'indice inférieur par défaut, soit 1 , le dimensionnement d'un tableau vect1 à n éléments de type real*4 peut se donner dans le sous-programme, au niveau inférieur, par l’instruction : real*4 vect1(n) la correspondance étant assurée. Si l'indice du premier élément du vecteur vect2 ne commence pas à 1 mais à une valeur diffé-rente, par exemple -5 , cette dimension doit figurer dans le dimensionnement du vecteur, la valeur pouvant être une constante entière ou celle d'un paramètre formel : real*4 vect2(-5:m) Le stockage des données dans des vecteurs est la façon la plus simple et la plus sûre de trans-mettre des informations entre les unités de programme. 2. Stockage des éléments d'une matrice Le stockage des éléments d'une variable indicée à deux dimensions ou matrice dépend du niveau dans lequel s'effectue l'affectation des valeurs numériques aux éléments du tableau bidimensionnel. 2.1 Affectation au niveau du dimensionnement numérique Soit un tableau a dont les dimensions maximales sont 20 lignes et 30 colonnes de type real*4 et soit une utilisation partielle de 12 lignes et 16 colonnes. Le programme partiel comporterait les ins-tructions suivantes :

* * Affectation au niveau supérieur * program anivo1 integer*2 i,j real*4 a(20,30) * ..... *

- 82 -


do i=1,12 do j=1,16 print *,'Elément',i,j,'=' read *,a(i,j) end do end do * .....

Dans ce cas, l'enregistrement s'effectue ligne après ligne sur l'ensemble du tableau, le com-pilateur calculant l'adresse en mémoire de chaque élément, compte tenu du rangement en colonne dans 20 lignes. Dans ce cas, les 12 premiers éléments définis en mémoire sont : a (1,1), a (2,1), ... , a (12,1) suivis de 8 places mémoire à 4 octets non définies, suivies de 12 éléments affectés de a (1,2) à a (12,2) , etc. 2.2. Affectation dans une unité de programme avec dimensions ajustables Choisissons un tableau a (50,50) , mais affectons les valeurs numériques à la variable indicée dans une procédure subroutine lire (...), le nombre de lignes et de colonnes pouvant être choisi par l'utilisateur. L'affectation s'effectue par l'intermédiaire d'une fonction alea ( a ) , générant des nombres réels pseudo-aléatoires compris entre - 100.0 et + 100.0 . Affichons ces éléments au moyen d'une seconde procédure subroutine affi (...) . L'exemple 13 possède la configuration ci-après.

* * Exemple 13 * Affectation de valeurs aléatoires dans une procédure * Lecture des valeurs numériques du tableau * program exem13 integer il,ic real*4 a(50,50) external affi,lire * write (*,'(//,15x,a,//,5x,a,\)') + 'AFECTATION ET EFFICHAGE DE VALEURS D''UN TABLEAU', + 'Donnez le nombre de lignes et colonnes (<=50) ' read *, il,ic * call lire (a,il,ic) call affi (a,il,ic) * end *

- 83 -


* Sous-programme d'affectation des éléments * subroutine lire (a,m,n) integer i,j,m,n real*4 a(m,n),an intrinsic abs external alea * write (*,'(12x,a,\)') 'un nombre réel avec 5 décimales ' read *, an an = abs(an) do i=1,m do j=1,n an =alea(an) a(i,j)=200.0*(an-0.5) end do end do end * * Sous-programme d'affichage * subroutine affi (a,m,n) integer i,j,m,n real*4 a(m,n) write (*,'(//,10x,a,//,5(1x,6f12.3,/))') + 'VALEURS CONTENUES DANS LES ELEMENTS', + ((a(i,j),i=1,m),j=1,n) end * * Fonction générant des nombres pseudo-aléatoires * real function alea (a) real*4 a,b intrinsic int * b=29.0*a alea=b-int(b) end Résultat de l'exécution du programme AFFECTATION ET AFFICHAGE DE VALEURS D'UN TABLEAU Donnez le nombre de lignes et de colonnes (<=50) 20 30 un nombre réel avec 5 décimales 12.34567 VALEURS CONTENUES DANS LES ELEMENTS -95.115 -64.978 73.473 33.420 -14.921 -0.555 -57.954 16.690 -40.782 81.250 -36.061 1.718 ................... Dans cet exemple, les éléments du tableau a , affectés et lus dans des procédures, seront sto-ckés dans des places mémoire contiguës, les indices utilisés dans les niveaux inférieurs n'étant pas identiques à ceux du niveau du dimensionnement numérique du programme principal.

- 84 -


Recommandation Pour éviter toute difficulté de recherche d'éléments avec 2 indices et plus, il est avantageux de prévoir les affectations, modifications et transformations de données aux mêmes niveaux des sous-programmes.

Les dimensions ajustables doivent être identiques pour le premier indice, éventuellement variable

pour le second. 3. Dimensionnement numérique par l'instruction parameter Le dimensionnement numérique des tableaux, au niveau le plus élevé de définition, peut s'effec-tuer par l'instruction parameter comme le montre l'exemple partiel ci-après. * * Dimensionnement des variables indicées par parameter * program dimen1 integer*2 il,ic,jl,jc parameter (il=20,ic=35,jl=10,jc=25) real*4 a(il,ic),b(jl,jc) ..... Cette programmation permet d'ajuster la place occupée par les données en mémoire à la taille du problème à résoudre, mais impose une compilation de l'unité de dimensionnement à chaque modifi-cation de l'instruction parameter . 4.2.3.4 DIMENSIONNEMENT PAR L'ASTÉRISQUE La dernière dimension de la variable de tableau, transmise sous forme de paramètre formel, est spécifiée par un astérisque dans la déclaration du paramètre formel. L'astérisque signifie que tous les éléments sont à disposition pour le stockage des données si les tableaux sont transmis entièrement. 1. Tableaux de type numérique L'exemple 14 suivant montre l'utilisation du dimensionnement par l'astérisque, soit dans un ta-bleau, soit pour un vecteur. L'exemple est semblable à l'exemple 13, l'utilisateur pouvant choisir le nombre de lignes et de colonne dans les sous-programmes. * * Exemple 14 * Démonstration du passage des paramètres, la dernière dimension * du vecteur a dans affi ou du tableau a dans lire étant * l'astérisque * Attention !!! * Si le nombre total d'éléments dépasse 2500, le système * d'exploitation est mis hors service par exemple sous MS-DOS * program exem14 integer il,ic

- 85 -


real*4 a(50,50) external affi,lire * write (*,'(//,7x,a,///,5x,a,\)') + 'AFFECTATION ET AFFICHAGE D''UN TABLEAU A DIMENSION PAR *', + 'Donnez le nombre de lignes : ' read *, il ic=2500/il * write (*,'(/,5x,a,i4,/,5x,a,//,5x,a,\)') + 'Le nombre limite de colonnes est : ',ic, + 'Le nombre maximal d''éléments est 2500 !', + 'Donnez le nombre de colonnes désiré : ' read *, ic * call lire (a,il,ic) call affi (a,il*ic) * end * * Sous-programme d'affectation des éléments * subroutine lire (a,m,n) integer i,j,m,n real*4 a(m,*),an intrinsic abs external alea * write (*,'(12x,a,\)') 'un nombre réel avec 5 décimales ' read *, an an = abs(an) do i=1,m do j=1,n an =alea(an) a(i,j)=200.0*(an-0.5) end do end do end * * Sous-programme d'affichage * subroutine affi (a,m) integer i,m real*4 a(*) * write (*,'(///,10x,a,//,5(1x,6f12.3,/))') + 'VALEURS CONTENUES DANS LES ELEMENTS', + (a(i),i=1,m) end * * Fonction générant des nombres pseudo-aléatoires * real function alea (a) real*4 a,b intrinsic int *

- 86 -


b=29.0*a alea=b-int(b) end Attention ! Le nombre total de places réservées en mémoire permet de stocker 2500 éléments de type real , l'astérisque signifiant que toutes les places mémoire sont à disposition, mais pas plus ! Si le produit du nombre de lignes par le nombre de colonnes dépasse cette valeur, l'exécution du program-me peut créer une erreur fatale et grave sur le système d'exploitation. Résultat de l'exécution du programme : AFFECTATION ET AFFICHAGE D'UN TABLEAU AVEC DIMENSIONS PAR *

Donnez le nombre de lignes : 20

Le nombre limite de colonnes est : 125 Le nombre maximal d'éléments est 2500 ! Donnez le nombre de colonnes désiré : 30 un nombre réel avec 5 décimales 23.45678

VALEURS CONTENUES DANS LES ELEMENTS

-50.679 -23.177 82.744 52.238 89.214 66.325 -25.020 -24.666 46.294 35.515 -90.596 3.117 .................. 2. Paramètre effectif avec indice de type character

Le dimensionnement de la variable indicée de type character par l'astérisque, servant de para-mètre formel, correspondant à un paramètre effectif représenté par un élément de tableau cité avec un indice, permet de transférer un certain nombre d'éléments entre les deux listes. Si m est le nombre total d'octets contenu dans la déclaration numérique au niveau supérieur, n le numéro d'ordre de l'élément cité dans le paramètre effectif et carac le nombre de caractères par élément, le nombre d'éléments transmissibles entre les deux listes est donné par : int((m + 1 - n*carac)/carac) Exemple de programme partiel :

character*16 noms(20) ..... call subnom (noms(6)) ..... subroutine subnom (z) character*16 z(1:*) ..... Dans cet exemple, m = 16 * 20 = 320 octets et n = 6 , carac = 16 . La taille de z dans le sous-programme est donnée par : int((320 + 1 - 6*16)/16) = 14 éléments. 3. Paramètre effectif de type numérique avec indice

Le dimensionnement de la variable indicée servant de paramètre formel, correspondant à un paramètre effectif représenté par un élément de tableau cité avec un indice, obéit aux règles sui-vantes : 1. Si le paramètre effectif est une variable de tableau sans indice, le nombre d'éléments trans-

missibles vers la variable servant de paramètre formel est égal au nombre d'éléments déclarés dans la variable du paramètre effectif.

- 87 -


2. Si le paramètre effectif est un élément de tableau, cité avec un indice ipf ,ce tableau étant di-mensionné à ipd , le nombre d'éléments transmissibles vers le tableau déclaré comme paramètre formel est : ipd + 1 - ipf .

Exemple : real*4 table(5000) call soupro (table(2000)) .....

subroutine soupro (b) real*4 b(1:*) Dans ce cas, la taille de la variable indicée b , déclarée dans le sous-programme soupro , est (avec ipd = 5000 et ipf = 2000 ) : 5000 + 1 - 2000 = 3001 éléments transmissibles. 3. Comme la taille de la variable de tableau n'est pas connue au départ, une variable indicée à di-

mension implicite ne peut pas s'utiliser comme : - identificateur de tableau dans une liste d'entrée-sortie, - identificateur d'unité pour un fichier interne dans une instruction d'entrée- sortie, - identificateur de format dans une instruction d'entrée-sortie.

4.2.4 APPEL ET RETOUR D'UN SOUS-PROGRAMME 4.2.4.1 INSTRUCTION D'APPEL D'UNE PROCÉDURE L'appel d'un sous-programme subroutine s'effectue par l'instruction de syntaxe :

call nomsub [ (par1 [ , par2 ] . . . ] avec : nomsub un identificateur de sous-programme subroutine , pari paramètre effectif, placé entre parenthèses, séparés du suivant s'il existe par la virgule,

selon les règles énoncées précédemment. L'instruction call transfère la ou les valeurs des paramètres effectifs connus (actual parameter) aux paramètres formels (dummy parameter) contenus dans la liste d'entrée du sous-programme subroutine de même identificateur. La liste accompagnant l'appel par call ... reçoit éventuellement les modifications ou les affectations des paramètres effectifs de sortie et mixtes, réalisées par le sous-programme. 4.2.4.2 RETOUR D'UN SOUS-PROGRAMME L'instruction return est utilisée pour passer de l'exécution d'un sous-programme, subroutine ou function , à l'instruction d'appel située dans une autre unité de programme. La syntaxe est :

return [ i ] avec : i un argument optionnel de type integer , constante ou expression, utilisable seulement dans les

sous-programmes subroutine avec retour sélectif sur l'étiquette de l'unité de programme contenant l'appel call ... , voir ci-après 4.2.5.3 .

Lorsque l'instruction return est lue dans le sous-programme function , le contrôle de l'exécution passe du sous-programme à l'instruction contenant la référence à la fonction dans l'unité de program-me d'appel. Lorsque l'instruction return est lue dans un sous-programme subroutine , le contrôle

- 88 -


passe à la première instruction exécutable suivant directement call ... , excepté si l'argument i est présent. Les sous-programmes function et subroutine peuvent contenir plusieurs instructions return. Aucune instruction return ne doit se trouver dans l'unité du programme principal. Dans un sous-programme, l'instruction end remplit également le même rôle. 4.2.4.3 TRANSMISSION D'ETIQUETTES Bien que le but de ce cours est d'apprendre à programmer sans introduire d'étiquettes, donnons encore une possibilité offerte par le langage FORTRAN . Cette programmation n'est applicable qu'à l'appel et l'utilisation d'une procédure subroutine, donc pas une fonction ! Pour spécifier un retour sélectif dans la liste des paramètres formels d'un sous-programme subroutine , il faut placer un asté-risque pour chaque option. Exemple : subroutine transi (a,b,c,*,*,*,m,n) Dans cette liste des paramètres formels, le premier astérisque correspond à return 1 , le second à return 2 et le troisième à return 3 . Les paramètres effectifs correspondants sont des étiquettes existantes dans l'unité de programme d'appel, précédées de l'astérisque, comme par exemple : call transi (a,b,c,*50,*80,*115,i,j) Lorsque le sous-programme transi se termine à l'instruction return 1 , le programme continue à l'instruction étiquetée 50 de l'unité d'appel, à l'instruction return 2 , le retour s'effectue à l'instruction étiquetée 80 de l'unité appelante, etc. Si le programme se termine à return ou à end, la règle usuelle est applicable à la poursuite du programme. Si l'argument est plus petit que 1 ou plus grand que le nombre d'étiquettes de la liste, le program-me continue avec un return comme s'il n'y avait pas d'argument.

4.3 FONCTIONS-FORMULES Les fonctions-formules uni-instruction, en anglais (statement-function), permettent de program-mer des expressions avec paramètres formels dans la même unité de programme, afin d'éviter une répétition de la tâche élémentaire accomplie par cette instruction. 4.3.1. DÉFINITION DE LA FONCTION-FORMULE La syntaxe générale de la fonction-formule est :

nomfonc ( liste_for ) = expr avec : nomfonc l'identificateur de la fonction, le type de cette fonction dépendant soit de la première lettre, soit d'une instruction implicit , soit d'une spécification particulière; liste_for une liste de paramètres formels composés de variables reliées à la liste des paramè-

tres effectifs lors de l'appel de la fonction-formule; expr une expression FORTRAN conforme au langage. Cette expression peut contenir des

fonctions "intrinsic", des sous-programmes function et d'autres fonctions-formules définies dans la même unité de programme.

A l'intérieur de l'unité de programme, l'identificateur de la fonction-formule ne peut s'utiliser que pour appeler la fonction-formule.

- 89 -


4.3.2 APPEL DE LA FONCTION-FORMULE La fonction formule est appelée simplement dans une expression FORTRAN dans la même unité de programme par :

nomfonc ( liste_eff ) avec : nomfonc l'identificateur de la fonction-formule, liste_eff la liste des paramètres effectifs. L'appel de la fonction-formule s'effectue toujours à l'intérieur d'une expression arithmétique ou lo-gique. Lorsqu'une référence à la fonction-formule apparaît, les valeurs des paramètres effectifs sont transmises aux paramètres formels de la définition de la fonction-formule. L'expression programmée dans l'instruction de définition est évaluée et le résultat unique transmis au lieu d'appel afin de pouvoir évaluer l'expression arithmétique ou logique en cours d'exécution. Les règles d'emploi de la fonction-formule sont : 1. Une instruction de définition d'une fonction-formule peut retourner une donnée numérique ou

logique, mais pas de type character. 2. L'instruction de définition doit rester unique dans la même unité de programme, l'identificateur

étant local dans cette unité.. 3. La fonction-formule doit être placée entre les déclarations ou spécifications et la première ins-

truction exécutable. Elle ne peut s'appeler que dans cette unité de programme. 4. La liste des paramètres formels doit contenir seulement des variables. La liste des paramètres

effectifs peut être constituée de constantes, variables ou expressions. 5. Le type des paramètres formels dans la fonction-formule est fixé soit implicitement, soit expli-

citement par une déclaration particulière ou dans une instruction implicit. 6. Une fonction-formule peut inclure une référence à une autre fonction-formule définie avant son

utilisation dans la même unité de programme. 7. Les paramètre formels utilisés dans la fonction-formule sont des variables locales dans l'unité de

programme. 4.3.3 EXEMPLES DE FONCTIONS-FORMULES Pour concrétiser ces règles, donnons diverses fonctions-formules définies dans un programme partiel. * integer i3,j,job real*4 a,ach,b,gamma,r,rayon,x,zw logical la,lb,lc,lex complex ccosh,zh,ref(2,3),u(8,10) intrinsic alog,iabs,mod,sqrt,tanh * * Définition des fonctions-formules * rayon(a,b) = sqrt(a*a+b*b) ach(x) = alog(x+sqrt(x*x-1.0)) lex(la,lb) = (la .and. .not. lb) .or. .not. (la .and. lb) job(j) = j+1-j/3*3 ....... * * Exemple d'appel des fonctions-formules * r = zw*tanh(5.0*ach(gamma)) lc=lex(lc,mod(iabs(i3),7) .ne. 2)

- 90 -


Le ou les paramètres formels sont nécessaires dans la définition de la fonction-formule, sinon le compilateur considère l'identificateur comme une variable ordinaire et non comme une fonction-for-mule. Si la définition est oubliée, le compilateur n'indiquera pas d'erreurs à la traduction et l'éditeur de lien recherchera un sous-programme function de ce nom. 4.3.4 EXEMPLE DE PROGRAMME Ce programme permet de trouver l'hypothénuse, le périmètre et l'aire d'un triangle rectangle à par-tir des deux côtés de l'angle droit. Il utilise trois fonctions-formules. * * Exemple 15 * Recherche des dimensions : hypothénuse, périmètre et aire * dans un triangle rectangle * program exem15 real*4 cote1,conte2,d1,d2 real*4 aire,hypo,perim character*1 rep logical contro intrinsic sqrt * * Programmation des 3 fonctions-formules * hypo calcul de l'hypothénuse * perim calcul du périmètre * aire calcul de l'aire du triangle * hypo (d1,d2) = sqrt (d1**2+d2**2) perim(d1,d2) = d1 + d2 + hypo(d1,d2) aire (d1,d2) = 0.5*d1*d2 * * Initialisation de la variable logique * data contro /.true./ * * Structure itérative avec tant que * do while (contro) write (*,'(//,10x,a,//,5x,a,$)') + 'DIMENSIONS DANS UN TRIANGLE RECTANGLE', + 'Donnez les 2 côtés de l''angle droit : ' read *, cote1,cote2 write (*,'(//,3(5x,a,f10.2,/),//,5x,a,$)') + 'L''hypothénuse vaut : ',hypo(cote1,cote2), + 'Le périmètre vaut : ',perim(cote1,cote2), + 'L''aire vaut : ',aire(cote1,cote2), + 'Désirez-vous un autre calcul (o/n) ? ' read (*,'(a1)') rep contro = (rep .eq. 'o') .or. (rep .eq. 'O') end do * end

- 91 -


Résultat de l'exécution d'un programme DIMENSIONS DANS UN TRIANGLE RECTANGLE Donnez les deux côtés de l'angle doit : 3 4 L'hypothénuse vaut : 5.00 Le périmétre vaut : 12.00 L'aire vaut : 6.00 Désirez-vous un autre calcul (o/n) ? n

4.4 SOUS-PROGRAMME : SUBROUTINE Le sous-programme subroutine est une unité de programme effectuant une ou le plus souvent de nombreuses tâches élémentaires ou complètes comme des opérations numériques, par exemple les opérations matricielles, logiques et sur des chaînes de caractères. Ce genre de sous-programme transforme les données transmises aux paramètres formels et retourne à l'unité appelante plusieurs données et même des tableaux complets. 4.4.1 SYNTAXE DE LA DÉFINITION Le sous-programme subroutine est une unité de programme compilée séparément, reliée aux autres unités lors de l'assemblage par l'éditeur de lien. La syntaxe générale de la déclaration est :

subroutine nomsub [ ( liste_form ) ] avec : nomsub l'identificateur du sous-programme subroutine . L'orthographe de l'identificateur est

absolument libre de toute contrainte et ne sert qu'à repérer le sous-programme. L'iden-tificateur nomsub est un nom symbolique global dans le programme exécutable et ne peut pas s'utiliser dans d'autres buts.

liste_form la liste des paramètres formels, si nécessaire, est composée de variables simples ou de tableau, d'astérisque et nombres entiers pour les retours sélectifs. La liste des para-mètres formels peut être vide. Dans ce cas, la première instruction du sous-programme est simplement :

subroutine nomsub Le sous-programme subroutine doit commencer toujours par l'instruction subroutine et se ter-miner par l'instruction end . Il ne doit pas contenir les instructions : program , function , block data ou une autre instruction subroutine . Il peut contenir toutes les autres instructions du langage y com-pris plusieurs instructions return . Le sous-programme peut appeler d'autres sous-programmes, mais pas lui-même. Cette unité de programme doit contenir toutes les spécifications nécessaires, comme par exemple les diverses déclarations de type, de dimensions, de zones communes, de data, etc. . A la compilation du sous-programme, il n'y a aucune liaison entre les identificateurs de variables utilisées dans l'unité de programme appelant et le sous-programme subroutine . Par contre, il y a liaison par adresse entre les paramètres effectifs et les paramètres formels des deux listes, ainsi que par l'instruction common lors de l'assemblage et de l'exécution du programme complet. Les mêmes identificateurs peuvent se retrouver dans plusieurs unités de programme tout en ayant ou non les mê-mes valeurs, le même type ou la même signification. Le sous-programme subroutine peut contenir une ou plusieurs instructions entry qui permettent une connexion à certains niveaux du sous-pro-gramme. L'appel d'un sous-programme subroutine se fait au moyen de l'instruction call ... .

- 92 -


4.4.2 CONFIGURATION GÉNÉRALE Dans ce premier exemple, donnons la configuration générale des unités composant un program-me complet. Ce programme se compose de trois unités distinctes : le programme principal princi , deux sous-programmes subroutine spro1 et spro2 .

* * Programme principal partiel * program princi integer i,j,k,n real a(60,60),b(60,8),c(60,4),f(60) external spro1,spro2 * ..... read *, n call spro1 (n,b,c) ..... call spro2 (n,a,b,c,f) ..... end * * Premier sous-programme partiel spro1 * subroutine spro1 (n,b,c) integer i,j,n real*4 b(n,4),c(n,2) ..... end * * Second sous-programme partiel spro2 * subroutine spro2 (n,a,b,c,f) integer i,j,k,l(60),m(60),n real*4 a(n,n),b(n,5),c(n,4),d,f(n) external minv ..... call minv (a,n,d,l,m) ..... end Le programme principal prévoit le dimensionnement d'un tableau a avec 3600 éléments réels, deux tableaux bidimensionnels b et c et d'un vecteur f . La variable entière n impose les dimen-sions maximales réellement utilisées dans les sous-programmes au moment de l'exécution. Le pre-mier sous-programme spro1 prévoit un dimensionnement des variables de tableau b et c , ces dimensions dépendant directement de la valeur affectée à la variable n dans le programme principal. L'affectation des variables indicées se réalise seulement sur une partie des tableaux, 4 colonnes pour b , 2 colonnes pour c . Le second sous-programme spro2 prévoit aussi un dimensionnement des variables de tableaux à partir de la valeur actuelle attribuées à n . Dans ce sous-programme, les éléments de la matrice carrée a (n,n) sont déjà placés dans les lignes et colonnes correctes. Ce sous-programme appelle un autre sous-programme effectuant l'inversion de la matrice a : minv (a,n,d,l,m) en lui transmettant les paramètres effectifs connus. Dans ce sous-programme , a est un vecteur de dimension n*n , d est le déterminant , l et m sont deux vecteurs retenant les indices de ligne et de colonne des élé-

- 93 -


ments lors de la pivotisation complète de la matrice. Le dimensionnement de ces deux vecteurs peut s'effectuer seulement au niveau du sous-programme d'appel. Dans cet exemple général, la mise en place des divers éléments s'effectue à l'intérieur des sous-programmes placés aux mêmes niveaux. De ce fait, les éléments sont rangés les uns à la suite des autres suivant l'ordre de rangement usuel, c'est-à-dire colonne après colonne. Ce rangement permet d'introduire un sous-programme d'une librairie extérieure à celle du langage travaillant sur des vec-teurs sans introduire une transformation : matrice -----> vecteur . Pour éviter toute erreur d'affectation et de transmission des données, il est vivement recommandé de vérifier la position des données lors du contrôle du programme. 4.4.3 EXEMPLE DE MULTIPLICATION MATRICIELLE Cet exemple complet démontre l'utilisation de trois sous-programmes subroutine pour affecter, afficher et calculer le produit de deux matrices : C = A * B avec : A matrice multiplicande B matrice multiplicatrice C matrice produit Les éléments sont créés par une fonction alea générant des nombres pseudo-aléatoires compris entre 0.0 et 1.0 afin de ne pas devoir introduire manuellement ces valeurs dans les tableaux A et B . L'organisation générale du programme est représentée dans la figure suivante :

Le sous-programme affich affiche les valeurs générées dans les trois matrices ligne après ligne à raison de 6 éléments par ligne. Le sous-programme matmul effectue la multiplication matricielle. Ce programme utilise la mise en forme des données au moyen de l'instruction write .

* * Exemple 16 * Multiplication matricielle : C = A * B * Les valeurs numériques sont générées par une fonction * créant des nombres pseudo-aléatoires * program exem16 integer id,nca,ncb,nla external affect,affich,matmul parameter (id=50) real*4 a(id,id),b(id,id),c(id,id) * write (*,'(///,20x,a,//,5x,a,$)') + 'MULTIPLICATION MATRICIELLE : C = A * B', + 'Donnez le nombre de lignes pour A (<=50) : ' read *, nla

- 94 -


write (*,'(12x,a,$)') 'le nombre de colonnes pour A (<=50) : ' read *, nca write (*,'(12x,a,$)') 'le nombre de colonnes pour B (<=50) : ' read *, ncb * write (*,'(///,10x,a,//)') 'MATRICE MULTIPLICANDE : A' call affect (a,nla,nca) call affich (a,nla,nca) write (*,'(///,10x,a,//)') 'MATRICE MULTIPLICATRICE : B' call affect (b,nca,ncb) call affich (b,nca,ncb) call matmul (a,b,c,nla,nca,ncb) write (*,'(///,10x,a,//)') 'MATRICE PRODUIT : C = A * B' call affich (c,nla,ncb) write (*,'(///,10x,a,///)') 'FIN DE L''EXEMPLE 16' end * * Sous-programme affect de création des éléments * subroutine affect (a,m,n) integer i,j,m,n real*4 a(m,n),alim,aini intrinsic abs external alea * write (*,'(5x,a,$)') 'Donnez la limite de génération : ' read *, alim write (*,'(12x,a,$)') 'un nombre réel avec 5 décimales : ' read *, aini alim = abs(alim) aini = abs(aini) * do i=1,m do j=1,n aini = alea(aini) a(i,j) = alim*(2.0*aini-1.0) end do end do end * * Sous-programme affich affichant les éléments des diverses * matrices à raison de 6 valeurs par ligne * a matrice à afficher * m,n nombre de lignes m et de colonnes n * subroutine affich (a,m,n) integer i,j,m,n real*4 a(m,n) * write (*,'(//)') do i=1,m write (*,'(5x,6E12.4)') (a(i,j),j=1,n) write (*,*) end do end *

- 95 -


* Fonction alea générant des nombres pseudo-aléatoires * real function alea (a) real*4 a,b intrinsic int b=29.0*a alea=b-int(b) end * * Sous-programme matmul calculant le produit matriciel * C = A * B * l nombre de lignes de A et C * m nombre de colonnes de A et de lignes de B * n nombre de colonnes de B et C * subroutine matmul (a,b,c,l,m,n) integer i,j,k,l,m,n real*4 a(l,m),b(m,n),c(l,m) * do i=1,l do j=1,n c(i,j)=0.0 do k=1,m c(i,j)=c(i,j)+a(i,k)*b(k,j) end do end do end do end Résultat de l'exécution du programme

MULTIPLICATION MATRICIELLE : C = A * B Donnez le nombre de lignes pour A (<=50) : 16 le nombre de colonnes pour A (<=50) : 20 le nombre de colonnes pour B (<=50) : 25

MATRICE MULTIPLICANDE : A Donnez la limite de génération : 100 un nombre réel avec 5 décimales : 1.23456 0.6045E+02 -0.4761E+02 0.3683E+02 0.6809E+02 -0.2553E+02 0.5957E+02 ..........

MATRICE MULTIPLICATRICE : B Donnez la limite de génération : 250 un nombre réel avec 5 décimales : 4.56789 -0.1559E+02 0.4782E+02 -0.1134E+03 0.2127E+03 0.1679E+03 -0.1306E+03 .......... MATRICE PRODUIT : C = A * B 0.2223E+05 0.8237E+04 -0.2379E+05 -0.4406E+05 -0.3599E+05 -0.4967E+04 .......... etc.

- 96 -


4.5 SOUS-PROGRAMME FUNCTION Le sous-programme function est une unité de programme permettant de déterminer une valeur qui est retournée dans l'expression d'appel de la fonction.

4.5.1 SYNTAXE DE LA DÉFINITION La syntaxe de la déclaration d'un sous-programme function est :

[ type ] function nomfonc [ ( liste_for ) ] avec : type type de la fonction : integer , integer*2 , integer*4 , real , real*4 , real*8 , double

precision , complex , complex*8 , complex*16 , logical , logical*2 , logical*4 ou character*len où len est la longueur de la chaîne de caractères produite par la fonction. Le type peut être omis si la déclaration est implicite, la première lettre de l'identificateur fixant alors le type.

nomfonc l'identificateur de la fonction. liste_for une liste d'un ou de plusieurs paramètres formels correspondant à la liste des para-

mètres effectifs de l'unité de programme appelant la fonction. L'instruction peut être donc complétée par un suffixe déclarant le type de la fonction, le type étant alors explicite. Cette méthode de programmation est vivement recommandée. L'instruction de déclaration d'une fonction de type character se donne par la syntaxe suivante :

character[*n ] function nomfonc [ ( liste_for ) ] avec : n un entier non signé, différent de zéro, ou un astérisque entre parenthèses, la longueur de la

fonction étant alors ajustable. Si la déclaration est : character*(*) , la longueur de la chaîne est celle qui est spécifiée dans l'unité d'appel de la fonction. Il est donc recommandé d'utiliser l'astérisque plutôt qu'une valeur numérique. Dans ce dernier cas, les longueurs doivent être absolument égales dans les instructions d'appel et de définition, sinon il y a erreur dans la transmission des données. Le nom de la fonction doit être déclaré dans une spécification character ... dans chaque unité contenant l'appel de la fonction.

Les règles applicables à la programmation d'un sous-programme function sont : 1. L'instruction function doit être la première instruction de l'unité de programme. Elle ne peut pas

contenir d'étiquette. 2. L'unité de programme contenant la définition de la fonction doit se terminer par l'instruction end . 3. Un sous-programme function ne doit pas contenir les instructions : subroutine , block data ,

program ou une seconde instruction function . 4. Le sous-programme function peut appeler un ou plusieurs sous-programmes function , mais pas l lui-même. 5. L'identificateur et le type de la fonction doivent être identiques dans les unités d'appel et de défini-

tion. Le nom de la fonction est global dans le programme. 6. L'instruction entry est utilisable dans un sous-programme function pour obtenir des points d'ac-

cès différents à cette fonction. 7. Dans l'unité de définition de la fonction, une valeur doit être attribuée à la fonction en faisant figu-

rer son identificateur, sans la liste de paramètres formels, au moins une fois dans le corps des instructions :

- soit à gauche du caractère = - soit dans une liste de valeurs à entrer comme par exemple dans une instruction read ...

- soit dans une liste d'appel à condition bien entendu que le sous-programme appelé attribue une valeur au paramètre correspondant.

8. A l'intérieur du sous-programme function , l'identificateur de la fonction peut s'utiliser comme identificateur de variable.

- 97 -


Après l'exécution de l'instruction return ou end, la valeur assignée à la fonction est associée à son nom dans l'unité de programme d'appel, là ou elle est citée dans une expression. 4.5.2 APPEL DE LA FONCTION La fonction est appelée en faisant figurer dans une ou plusieurs expressions de l'unité de pro-gramme appelante le nom de la fonction suivie des paramètres effectifs. La syntaxe de l'appel de la fonction est :

nomfonc [ ( liste_eff ) ] avec : nomfonc l'identificateur de la fonction connu du programme exécutable, liste_eff la liste des paramètres effectifs transmis à la liste des paramètres formels dans l'unité

de programme servant de définition de la fonction. La fonction est alors évaluée en remplaçant les paramètres formels par les paramètres effectifs, le résultat de l'évaluation étant attribué à l'identificateur de la fonction placé dans l'instruction d'appel. Les paramètres effectifs sont des paramètres d'entrée dans la définition de la fonction, bien que les règles générales soient applicables au passage des données. On parle d'effet de bord si l'un des paramètres est mixte ou de sortie, méthode de programmation à éviter si possible à moins de vouloir réaliser des conditions particulières d'affectation. 4.5.3 EXEMPLE D'UTILISATION D'UNE FONCTION L'utilisation d'une fonction se fait toujours dans une expression arithmétique, logique ou alphanu-mérique. L'unité de programme doit contenir une déclaration de la fonction dans une instruction external si l'identificateur de fonction est utilisé comme paramètre effectif. Comme dans dans la procédure subroutine , les paramètres formels ne peuvent pas figurer dans des instructions : data , equivalence , parameter , intrinsic , save ou common . Dans le corps de la fonction, il est possible ou nécessaire de déclarer le type des variables locales et des paramètres formels. Les variables locales sont stockées dans la pile (stack) par défaut et les valeurs attribuées à ces variables sont perdues lorsque le déroulement du programme quitte le sous-programme function ... ou subroutine . L'instruction save permet de conserver ces valeurs au-delà du sous-programme. Exemple d'appel d'une fonction : Soit à écrire un programme permettant d'enregistrer jusqu'à 50 valeurs réelles dans deux vec-teurs, d'en calculer la somme et la moyenne arithmétique. * * Exemple 17 * Calcul de la somme et de la moyenne de nombres réels * program exem17 integer i,na,nb real*4 a(50),b(50),somme,somma,sommb character*1 rep external affect,somme * write (*,'(//,15x,a,//,10x,a,/)') + 'ENREGISTREMENT ET MOYENNE DE VALEURS REELLES', + 'TABLEAU A' call affect (a,na) write (*,'(//,10x,a,/)') 'TABLEAU B' call affect (b,nb) *

- 98 -


somma = somme(a,na) sommb = somme(b,nb) write (*,'(//,2(5x,a,f10.3,/,5x,a,f21.3,/),//)') + 'Somme des éléments du tableau A : ',somma, + 'Moyenne arithmétique : ',somma/na, + 'Somme des éléments du tableau B : ',sommb, + 'Moyenne arithmétique : ',sommb/nb end * * Sous-programme affect d'enregistrement * subroutine affect (d,m) integer i,m real*4 d(m) * write (*,'(/,10x,a,//,5x,a,$)') + 'Enregistrement des valeurs dans le tableau', + 'Donnez le nombre d''éléments désirés (<=50) : ' read *, m do i=1,m write (*,'(5x,a,i3,a,$)') 'Elément no. ',i,' = ' read *, d(i) end do end * * Fonction calculant la somme des éléments * real function somme (d,m) integer i,m real*4 d(m) * somme=0.0 do i=1,m somme=somme+d(i) end do end Dans cet exemple. le programme principal prévoit des vecteurs a et b avec 50 éléments, le nombre réellement affecté étant déterminé dans le sous-programme affect . La somme des élé-ments des deux tableaux est obtenue dans la fonction somme , le résultat étant affecté aux variables somma et sommb dans le programme principal. Résultat de l'exécution du programme ENREGISTREMENT ET MOYENNE DE VALEURS REELLES TABLEAU A Enregistrement des valeurs dans le tableau Donnez le nombre d'éléments désirés (<=50) : 5 Elément no. 1 = 10 ..... Elément no. 5 = 50 TABLEAU B Enregistrement des valeurs dans le tableau

- 99 -


Donnez le nombre d'éléments désirés (<=50) : 8 Elément no. 1 = 22 ... Elément no. 8 = 79 etc.

4.6 ENTRÉES ET ZONES COMMUNES Ce sous-chapitre traite les instructions complémentaires d'entrées additionnelles dans les sous-programmes subroutine et function , de sauvegarde des données, des zones communes en mé-moire vive et de l'équivalence des places en mémoire. Il se termine par le sous-programme d'initia-lisation block data . 4.6.1 ENTRÉES ADDITIONNELLES 4.6.1.1 SYNTAXE DE L'INSTRUCTION ENTRY L'instruction entry permet d'entrer dans le corps d'un sous-programme subroutine ou function en un point situé après la première instruction exécutable dans le sous-programme. La syntaxe de cette instruction est :

entry nomid [ ( liste_form ) ] avec : nomid l'identificateur de l'entrée additionnelle, ce nom étant global dans le programme exé-

cutable. liste_form la liste des paramètres formels, si nécessaire, séparés par la virgule et placés entre

parenthèses. L'instruction entry est une instruction non-exécutable. Elle est placée dans le corps du sous-pro-gramme subroutine ou function et le déroulement se poursuit à la première instruction exécutable suivant la spécification entry . Les règles à observer sont : 1. L'instruction entry ne doit pas se trouver à l'intérieur d'une boucle itérative do ... ou à l'intérieur

d'un bloc if ... . 2. L'instruction entry n'étant pas exécutable, lorsqu'elle est lue pendant l'exécution d'un sous-pro-

gramme en partant d'instructions la précédant, elle est tout simplement ignorée. 3. Le nombre de paramètres formels dans la liste d' entry , leur type, peuvent être choisis différem-

ment de celui de la liste dans la déclaration du sous-programme. Seule condition à respecter : aucun paramètre formel ne peut s'utiliser avant sa présence dans une liste de paramètres de définition.

4. Le nombre de points d'entrée secondaire n'est pas limité, chacun ayant un identificateur différent et unique dans le programme exécutable.

5. La récursivité n'est pas possible avec l'instruction entry . 6. Les identificateurs d'une fonction, définis par entry et par function, sont habituellement de même

type, leur déclaration étant implicite ou explicite. 7. L'appel du sous-programme à ce niveau d'entrée s'effectue par l'instruction call pour une procé-

dure subroutine et par une référence à son identificateur pour une fonction. 4.6.1.2 ENTRY DANS UN SOUS-PROGRAMME SUBROUTINE L'instruction d'appel d'un point d'entrée secondaire dans une procédure subroutine doit contenir : - l'instruction call ,

- 100 -


- suivie de l'identificateur attribué au point d'entrée secondaire, - suivi de la liste des paramètres effectifs, si nécessaire. La liste des paramètres formels doit correspondre en nombre et type avec la liste des paramètres effectifs, les retours sélectifs pouvant également s'introduire dans la programmation. Exemple d'appel d'une entrée secondaire : * * * Programme principal * Sous-programme contro * * program princi subroutine contro (a,b,c) real*4 x,y,z real*4 a,b,c ..... ..... call contro (x,y,z) if (a .gt. b) a = a - 0.5 ..... ..... call direct (x,y) entry direct (a,b) ..... a = a - 2.0*b end ..... end 4.6.1.3 ENTRY DANS LE SOUS-PROGRAMME FUNCTION Les identificateurs d'entrée principale et d'entrée secondaire sont habituellement de même type. Avant le retour à l'instruction d'appel de la fonction, située dans une expression, l'identificateur doit être affecté d'une valeur. Exemple de sous-programme function : La fonction proposée permet le calcul des trois fonctions hyperboliques : sinus, cosinus et tan-gente sans faire appel aux fonctions existantes de la librairie FORTRAN. Cet exemple montre le prin-cipe d'une programmation avec entrée secondaire. Pour ne pas introduire les identificateurs des fonc-tions "intrinsic" , les identificateurs sont modifiés en leur adjoignant x . * * Exemple 18 * Utilisation d'entrées secondaires dans une fonction * program exem18 integer ipoint logical lcont real*4 fonc1,fonc2,x character*1 rep intrinsic sinh,cosh,tanh external sinhx,coshx,tanhx data lcont /.true./ do while (lcont) write (*,'(//,10x,a,//)') + 'ACCES AUX ENTREES SECONDAIRES D''UNE FONCTION' write (*,'(/,8x,a,//,3(5x,a,/),//,8x,a,$)') + 'Vous avez le choix entre les fonctions :', + '1. Sinus hyperbolique', + '2. Cosinus hyperbolique', + '3. Tangente hyperbolique', + 'Quel point adoptez-vous ? ' read *, ipoint write (*,'(/,5x,a,$)') 'Donnez l''argument x : ' read *, x

- 101 -


if (ipoint .eq. 1) then fonc1 = sinhx(x) fonc2 = sinh(x) else if (ipoint .eq. 2) then fonc1 = coshx(x) fonc2 = cosh(x) else if (ipoint .eq. 3) then fonc1 = tanhx(x) fonc2 = tanh(x) end if write (*,'(//,5x,a,2f12.6,//,a,$)') + 'Résultat de l''évaluation : ',fonc1,fonc2, " 'Désirez-vous un autre calcul (o/n) ? ' read (*,'(a1)') rep lcont = (rep .eq. 'o') .or. (rep .eq. 'O') end do * end * * Fonction avec entrée secondaire * real function tanhx(x) real*4 x,y * fsinh(y)=exp(y)-exp(-y) fcosh(y)=exp(y)+exp(-y) * tanhx = fsinh(x)/fcosh(x) return * entry sinhx(x) sinhx = fsinh(x)/2.0 return * entry coshx(x) coshx = fcosh(x)/2.0 end Le sous-programme function tanhx présente tout d'abord deux fonctions-formules calculant le double du sinus et du cosinus hyperboliques de l'argument x . Le calcul de la tangente, du sinus ou du cosinus hyperbolique fait appel chaque fois à l'une ou aux deux fonctions-formules placées avant les instructions de calcul proprement dites. La tangente s'évalue à partir de la définition de la fonction, le sinus et le cosinus par des entrées secondaires. Résultat de l'exécution du programme ACCES AUX ENTREES SECONDAIRES DANS UNE FONCTION

Vous avez le choix entre les fonctions

1. Sinus hyperbolique 2. Cosinus hyperbolique 3. Tangente hyperbolique

Quel point adoptez-vous ? 1

Donnez l'argument x : 1.25

- 102 -


Résultat de l'évaluation : 1.601919 1.601919

Désirez-vous un autre calcul (o/n) ? n 4.6.2 PARAMÈTRES PROCÉDURAUX Les instructions de spécification intrinsic et external permettent de passer des sous-program-mes de la librairie FORTRAN ou écrits par le programmeur dans la liste des paramètres effectifs. Les syntaxes de ces deux instructions ont été décrites précédemment sous 4.1.1 et 4.2.1. 4.6.2.1 EXEMPLE DE PARAMÈTRE PROCÉDURAL L'exemple proposé permet de résoudre numériquement une équation différentielle du premier or-dre par la méthode de Runge-Kutta . Il fait intervenir deux sous-programmes : 1. procédure subroutine runge utilisant l'algorithme classique du quatrième ordre, 2. une fonction fonc passée sous forme de paramètre procédural. * * Exemple 19 * Solution d'une équation différentielle par Runge-Kutta * Ce programme comprend deux sous-programmes * runge procédure de Runge-Kutta * fonc fonction : y' = f(x,y) à programmer * program exem19 integer i,incr real*4 deltax,x0,x1,xmax,xmin,y0,y1,ymin external fonc * write (*,'(//,14x,a,/,25x,a,//,5x,a,$)') + 'SOLUTION D''UNE EQUATION DIFFERENTIELLE DU 1er ORDRE', + 'PAR LA METHODE DE RUNGE-KUTTA', + 'Donnez la valeur intiale pour x0 : ' read *, xmin write (*,'(12x,a,$)') 'la valeur initiale y0 : ' read *, ymin write (*,'(12x,a,$)') 'la borne supérieure xmax : ' read *, xmax write (*,'(12x,a,$)') 'le nombre de pas de calcul : ' read *, incr deltax = (xmax-xmin)/incr y1 = ymin * write (*,'(///,15x,a,//,15x,a,9x,a,12x,a,//,i20,2f15.6,/)') + 'SOLUTION DE L''EQUATION DIFFERENTIELLE', + 'numéro','x =','y =',0,xmin,ymin do i=1,incr x0=xmin+(i-1)*deltax y0=y1 call runge (x0,y0,deltax,fonc,x1,y1) write (*,'(i20,2f15.6)') i,x1,y1 if (mod(i,5) .eq. 0) write (*,*) end do

- 103 -


* end * * Procédure de Runge-Kutta du 4ième ordre * subroutine runge (x0,y0,h,ff,x1,y1) real*4 h,x0,y0,y1 real*4 a(4),delta * a(1)=ff(x0,y0)*h do i=1,2 a(i+1)=ff(x0+0.5*h,y0+0.5*a(i))*h end do a(4)=ff(x0+h,y0+a(3))*h delta=(a(1)+2.0*(a(2)+a(3))+a(4))/6.0 x1 = x0+h y1 = y0+delta end * * Fonction y'=f(x,y) * Programmez la fonction fonc = y' * real function fonc(x,y) real*4 x,y fonc = x+y end Résultat de l'exécution du programme

SOLUTION D'UNE EQUATION DIFFERENTIELLE DU 1er ORDRE PAR LA METHODE DE RUNGE-KUTTA

Donnez la valeur intiale pour x0 : 1 la valeur initiale pour y0 : 1 la borne supérieure xmax : 3 le nombre de pas de calcul : 40

SOLUTION DE L'EQUATION DIFFERENTIELLE

numéro x = y = 0 1.000000 1.000000 1 1.050000 1.103813 ................................... 40 3.000000 18.167170 4.6.2.2 FONCTIONS DE LA LIBRAIRIE EN PARAMÈTRE Il est également possible de transférer dans un sous-programme une ou plusieurs fonctions de la librairie FORTRAN par l'intermédiaire des paramètres effectifs. Les fonctions servant de paramètres doivent se déclarer dans une instruction intrinsic . Cette instruction est à placer avec les autres spécifications au début de l'unité de programme. Elle informe le compilateur que l'identificateur de la fonction peut s'utiliser comme paramètre effectif et ne représente donc pas une variable. Les iden-tificateurs de fonctions de conversion ne peuvent pas s'utiliser comme paramètres, voir 4.1.1.1 . Exemple de programme partiel transmettant des fonctions en paramètre

- 104 -


* * * Transmission de fonctions * Sous-programme * * program transm subroutine calc (x,f,y) real*4 x1,x2,x3,x4,y1,y2,y3,y4 real*4 f,x,y intrinsic sin,cos,sinh,cosh y = 1.0+f(x)**2 ..... end call calc (x1,sin,y1) ..... call calc (x2,cos,y2) call calc (x3,sinh,y3) call calc (x4,cosh,y4) ...... end Dans cet exemple, l'appel du sous-programme calc transfère les fonctions déclarées comme "intrinsic" au sous-programme calc en remplaçant f (x) par la fonction correspondante de la librairie FORTRAN. 4.6.3 ZONES DE RÉSERVATION COMMUNE L'instruction common permet le rangement de données de plusieurs unités de programme dans une zone de mémoire commune. Cette instruction facilite la communication entre les diverses unités et peut aussi remplacer la transmission des valeurs par l'intermédiaire des listes de paramètres effec-tifs. 4.6.3.1 INSTRUCTION COMMON "BLANC" La possibilité de transmettre dans toutes les unités de programme les informations contenues dans une zone commune s'effectue par l'instruction :

common liste avec : liste la liste des variables à placer dans la zone commune, les variables étant séparées les unes

des autres par la virgule. Cette instruction de déclaration est appelée common blanc car elle définit une zone commune sans identificateur de zone. Elle peut servir à dimensionner des variables de tableaux, mais le même tableau ne peut être dimensionné qu'une seule fois dans la même unité de programme. Un paramètre effectif ne peut pas figurer dans cette instruction et la même variable ne peut pas apparaître dans plusieurs instructions common . Exemples : common a,b,f(12,5),g,h(6,4,10) Cette instruction réserve donc une place commune unique aux variables citées dans la liste et les places mémoire correspondantes peuvent stocker des données dans un format interne selon le type de la variable. C'est la raison pour laquelle il est recommandé d'introduire une certaine systématique dans la réservation de la place. Afin d'éviter tout mélange de variables de tailles différentes, il est utile de ranger ces variables par ordre d'occupation décroissante, soit : - complex*16 , complex*8 - real*8 - real*4 - integer*4 , logical*4 - integer*2 , logical*2 - character*n .

- 105 -


Les dernières classes vont présenter des difficultés de stockage si une directive de compilation prévoit 2 octets pour le rangement des données logiques et entières. Le type character*n va aussi compliquer le rangement, car les enregistrements de chaînes de caractères sont organisés en octets, et non en mots. Dans ce cas, il est sage de prévoir un dimensionnement pour n multiple de 4 pour les variables de type character . Chaque unité de programme ne peut contenir qu'une instruction common blanc , le nombre de variables citées dans la liste ne devant pas nécessairement être le même dans toutes les unités de programme. La longueur maximale, y compris les extensions éventuelles par l'instruction equiva-lence , doit figurer dans le programme principal. 4.6.3.2 INSTRUCTION COMMON IDENTIFIÉ Quand le programme prévoit une zone commune très étendue et que les diverses unités de pro-gramme n'utilisent qu'une partie de cette réservation en mémoire, le langage FORTRAN prévoit des zones communes reconnues par un identificateur de zone placé entre barres obliques. Les identi-ficateurs de blocs de zone commune sont des noms globaux dans le programme exécutable. La syn-taxe de l'instruction est :

common / idcom1 / liste [ [ , ] [ / idcom2 / liste2 ] ... ] avec : idcomi identificateur d'un bloc de zone commune, nom global dans le programme, listei une liste de variables, tableaux et éléments de tableaux, un paramètre formel ne pouvant

pas apparaître dans cette liste. Dans chaque instruction common , les variables qui suivent le nom de bloc sont déclarées com-me faisant partie de la zone commune. Les variables de chaque liste sont séparées les unes des autres par la virgule, cette dernière étant facultative entre les blocs successifs. Les règles complémentaires sont : 1. Les identificateurs de sous-programmes subroutine , function , entry , block data ou une

fonction de la librairie FORTRAN ne doivent pas figurer dans une instruction common . 2. L'identificateur d'une zone de bloc common doit rester unique dans le programme; il peut être

identique à celui d'une variable, méthode de programmation peu recommandée. 3. Les identificateurs cités dans les instructions data , excepté ceux qui sont cités dans le sous-

programme block data , ne doivent pas apparaître dans une instruction common dans la même unité de programme.

4. La place occupée en mémoire commune par les variables de la liste doit être absolument iden-tique dans toutes les unités de programme utilisant la même zone commune, repérée par le même identificateur.

5. Les instruction common blanc et les blocs common peuvent s'écrire dans la même instruction. 6. L'instruction common faisant partie des instructions de déclaration, elle se place après implicit

et parameter , mais avant save , data et les fonctions-formules. Exemple général * * Programme principal * program execom real*4 a,b,c,d,e,f,g,h * common /bloc1/a,b,c /bloc2/d,e,f common g,h * * Sous-programme 1 * subroutine sub1 real*4 x,y,z common /bloc1/x,y,z

- 106 -


..... end * * Sous-programme 2 * subroutine sub2 real*4 p,q,x,y,z common /bloc1/x,y,z common p,q ..... end

Dans cet exemple général, le programme principal prévoit des blocs de zones communes dési-gnées par bloc1 et bloc2 , chaque bloc permettant de stocker 3 variables de type real*4 et un common blanc avec deux variables de type real*4 . Le premier sous-programme utilise le bloc commun bloc1 , les variables citées étant x , y , z , situées dans les mêmes places mémoire que les variables a , b , c du programme principal. Le sous-programme 2 utilise le bloc commun bloc2 , en stockant les variables x , y , z , dans les mêmes places mémoire que d , e , f , du programme principal. Enfin, les variables p et q , situées dans le common blanc, occupent les mêmes places mémoire que les places réservées g et h dans le programme principal. 4.6.4 SAUVEGARDE PAR L'INSTRUCTION SAVE Les données stockées dans les variables locales utilisées dans les sous-programmes sont per-dues après le retour à l'unité de programme d'appel. Il est possible d'en conserver une partie ou toutes les variables locales par l'instruction :

save liste_var avec : liste_var liste des variables locales au sous-programme : variables simples ou de tableaux, élé-

ments de tableaux, de sous-chaînes de caractères séparés par la virgule. La liste peut comprendre un ou plusieurs blocs communs , placés entre barres obliques.

Les identificateurs de sous-programmes, d'entités citées dans les blocs communs et les paramè-tres formels ne peuvent pas figurer dans la liste. Si un bloc commun est cité dans une liste de save d'un sous-programme, l'instruction save doit s'introduire dans chaque unité de programme citant ce bloc commun. L'instruction save se place après les déclarations, mais avant data .

- 107 -


4.6.5 ADRESSES ÉQUIVALENTES EN MEMOIRE L'instruction equivalence assigne les mêmes adresses en mémoire à deux ou plusieurs variables simples ou de tableaux à l'intérieur d'un programme. 4.6.5.1 SYNTAXE DE L'INSTRUCTION La syntaxe générale de cette instruction est :

equivalence ( liste1 ) [ , ( liste2 ) ... ] avec : listei une liste de variables, d'éléments de tableau, de tableaux ou références à des sous-chaînes

de caractères séparée par des virgules. La liste doit comporter au moins deux composantes. Chaque variable d'une même liste occupe une zone en mémoire qui commence exactement au même endroit. Les règles applicables à l'instruction equivalence sont : 1. La déclaration equivalence doit être placée dans le groupe des instructions non exécutables en

tête du programme, après implicit , dimension , common , character et les spécificateurs de type. .

2. Les composantes de la liste doivent être soit de type numérique , soit de type character, le mélange des types n'étant pas autorisé.

3. Un identificateur de tableau apparaissant dans la liste de l'instruction indique une adresse équivalente de mémoire pour le premier élément du tableau.

4. Un paramètre formel ou effectif ne peut pas figurer dans une instruction equivalence . Exemples :

real*8 dprem integer*2 ivar(4) equivalence (dprem,ivar(1)) Les quatre éléments de la variable entière ivar occupent 4*2 octets = 8 octets, soit exactement la même portion de mémoire que la variable dprem en double précision, soit 8 octets. character mot*16,nom*12 equivalence (mot,nom) Les 12 premiers caractères des chaînes mot et nom occupent exactement la même position en mémoire. La variable nom est dans ce cas équivalente à la sous-chaîne mot (1:12) . Une opération intéressante est la séparation des parties réelle et imaginaire d'un tableau d'éléments de type complex en les égalant à un tableau d'éléments réels. 4.6.5.2 ÉQUIVALENCE DE TABLEAUX NUMÉRIQUES Il est donc possible d'équivalencer deux ou plusieurs tableaux numériques, des variables simples avec des éléments de tableaux. Si des éléments de tableaux figurent dans une instruction equiva-lence , cela peut imposer l'équivalence entre d'autres éléments de ces tableaux. Exemple :

real*4 a(10),b,x(4,5) equivalence (a(2),x(2,2),b) La position des éléments en mémoire peut se représenter par les éléments suivants :

x(1,1) x(2,1)

- 108 -


x(3,1) x(4,1) a(1) x(1,2) a(2) x(2,2) b niveau de définition de l'équivalence a(3) x(3,2) a(4) x(4,2) a(5) x(1,3) ................. etc. Les spécificateurs d'une même liste ou de listes différentes ne doivent pas être contradictoires. En particulier, il faut vouer un soin attentif aux variables de 2 octets équivalencées aux variables de 4 octets et se référer au mode de stockage des données. Tout changement de la valeur d'une variable affecte aussi celles qui lui sont équivalencées. L'ins-truction equivalence permet d'économiser de la place en mémoire, de donner plusieurs noms à une même composante ou à simplifier la transformation d'un tableau unidimensionnel en tableau multi-dimensionnel ou vice versa. Dans une instruction equivalence , une variable de tableau multidi-mensionnel peut se désigner par un indice unique, de type integer , qui indique son numéro de ran-gement. Par exemple, l'élément a (1,1) du tableau a (5,6) peut s'écrire a (1) et l'élément a (3,5) devient a (23) . 4.6.5.3 ÉQUIVALENCE DE CHAINES DE CARACTÈRES Lorsque l'instruction equivalence est utilisée entre un caractère d'une sous-chaîne et un carac-tère d'une autre sous-chaîne, l'instruction engendre l'équivalence entre les autres caractères des deux chaînes complètes. Exemple :

character nom*16,mot*7 equivalence (nom(9:11),mot(3:5)) soit l'alignement ci-après : 9 11 nom : N N N N N N N N N N N N N N N N mot : M M M M M M M 3 5 Cette instruction pourrait aussi s'écrire : equivalence (nom(10:10),mot(4:4)) 4.6.5.4 ÉQUIVALENCE ET COMMON Une variable simple ou de tableau peut apparaître dans les instructions equivalence et com-mon dans la même unité de programme. Les restrictions à l'occupation en mémoire sont les suivantes : 1. L'instruction equivalence peut agrandir la zone commune d'une instruction common blanc au-

delà de son dernier élément : Exemple : real*4 a(5),b,c,d(5,2),p(20) common a(4),b,c,d(5,2) equivalence (p(1),b)

- 109 -


Les 12 premiers éléments de la variable indicée p appartiennent à la zone commune originale (4 octets pour b et c , 40 octets pour d ), tandis que les 8 derniers, soit 32 octets, forment l'exten-sion de la zone.

L'extension de l'instruction suivante n'est pas admissible : equivalence (a(1),p(5)) 2. La place occupée en mémoire par chaque bloc common identifié doit être égale dans toutes les

unités de programme. Si l'instruction equivalence est employée pour étendre un common identifié dans une unité de programme, il faut ajuster cette zone commune de telle sorte que la règle du nombre d'octets constant soit satisfaite.

3. Dans une même unité de programme, deux variables simples ou de tableaux citées dans un common ne peuvent pas être équivalencées car il y aurait redondance. Exemple illégal :

character*16 mot1,mot2,motvid common mot1,mot2,motvid equivalence (mot1,motvid) car mot1 et motvid sont définis dans 2 modes de stockage contradictoires. 4. Une instruction equivalence ne doit pas spécifier que des places mémoire consécutives soient

équivalencées en places non consécutives. Exemple illégal :

real*4 dvar(2) real*8 douvar(2) equivalence (dvar(1),douvar(1),dvar(2),douvar(2)) 5. Il est interdit d'équivalencer des variables simples et de tableaux placées dans différents blocs

common . Cette opération est incompatible car l'instruction equivalence indique une occu-pation superposée des données en mémoire, tandis que chaque bloc common impose un stockage séparé.

4.6.6 SOUS-PROGRAMME BLOCK DATA Un sous-programme block data est un sous-programme particulier permettant d'assigner des valeurs aux variables d'un ou plusieurs blocs common au moyen d'instructions data . La syntaxe de cette déclaration est :

block data [ nom ] avec : nom un identificateur global, facultatif si le programme ne contient qu'un seul sous-programme

block data . Entre l'instruction de spécification block data et l'instruction finale de compilation end ne peu-vent figurer que des déclarations de type et : common , parameter , dimension , equivalence , implicit , save et data . Ce sous-programme ne peut donc pas contenir d'instructions exécutables, ni des étiquettes. Le but de ce sous-programme est d'affecter des valeurs initiales à tout ou à une partie des varia-bles citées dans un bloc common identifié donc à l'exclusion d'un common "blanc". Il faut définir les types de tous les éléments à affecter et leurs dimensions si nécessaire. L'affectation proprement dite s'effectue dans une ou plusieurs instructions data . Exemple : Définition de valeurs numériques et de prénoms dans un block data.

- 110 -


* * Exemple 20 * Initialisation pas block data * program exem20 integer*4 i,nombre(10) real*4 pi logical vrai character*16 prenom(6) common /bloc1/pi,nombre,vrai,prenom * write (*,'(//,10x,a,//,5x,a,10i4,/,5x,a,f10.7,/,5x,a,l3)') + 'INITIALISATION PAR DATA DANS UN BLOC COMMON', + 'Le tableau contient : ', (nombre(i),i=1,10), + 'La valeur de pi est : ',pi, + 'La valeur logique est ',vrai do i=1,6 write (*,'(/,5x,a,i2,a,a16)') + 'Le prénom stocké en ',i,' est : ',prenom(i) end do end * * Sous-programme block data d'initialisation * block data donnee integer*4 i,nombre(10) real*4 pi logical vrai character*16 nom(6) * common /bloc1/pi,nombre,vrai,nom data pi,nombre,vrai /3.141593,1,3,5,7,9,11,13,15,17,19,.true./ data nom(1),nom(2),nom(3),nom(4),nom(5),nom(6) + /'Anne-Marie','Bertrand','Célestine','Francis', + 'Joséphine','Roger'/ end Résultat de l'exécution du programme :

INITIALISATION PAR DATA DANS UN BLOC COMMON

Le tableau contient : 1 3 5 7 9 11 13 15 17 19 La valeur de pi est : 3.1415930 La valeur logique est : T Le prénom stocké en 1 est : Anne-Marie Le prénom stocké en 2 est : Bertrand Le prénom stocké en 3 est : Célestine Le prénom stocké en 4 est : Francis Le prénom stocké en 5 est : Joséphine Le prénom stocké en 6 est : Roger

- 111 -

CHAPITRE 5

MISE EN FORME DES DONNÉES Le langage FORTRAN , bien que datant de plus de 30 ans, possède une collection d'instructions très efficaces facilitant fortement la lecture et surtout l'écriture des données numériques et alphanumériques à l'écran, dans les fichiers, sur les périphériques et dans les variables. L'entrée au clavier en mode direct des valeurs à affecter aux variables, s'effectue par l'intermédiaire de l'instruction read *,... , et la sortie directe des données par l'instruction print *, ... sans mise en forme. Nous avons utilisé l'instruction write (*, ... ) dans les exemples précédents afin de faciliter les affichages.

5.1 MISE EN FORME DES ENTRÉES - SORTIES La lecture des valeurs numériques ou des chaînes de caractères consiste à transférer d'un périphé-rique, clavier, carte ou bande perforée, disque dur ou bande magnétique, de l'information vers la mémoire vive de l'ordinateur tandis que l'écriture des données consiste à transférer l'information de la mémoire vive vers les divers périphériques. Lecture et écriture de données exigent dans la plupart des cas une trans-cription de l'information et une description rigoureuse de la configuration du texte. Quatre instructions sont utilisées dans ce but en FORTRAN : 1. lecture : read 2. écriture directe : print 3. écriture élaborée : write 4. description du mode de transfert : format . Ce chapitre traite des possibilités de mise en forme des données seulement dans les opérations d'entrée / sortie. Il faut absolument se souvenir des genres de représentations : interne en mémoire vive, externe sur les périphériques. Les particularités des échanges avec les fichiers seront décrites au chapitre 6 suivant. 5.1.1 INSTRUCTION DE MISE EN FORME L'instruction de configuration externe de l'information est fixée par le mot clef du langage : format . Par abus de langage, on utilise très souvent l'expression formater (comme nous avons utilisé précé-demment l’expression équivalencer) dans une opération de mise en forme. 5.1.1.1 INSTRUCTION FORMAT La syntaxe générale de l'instruction est :

etiq format ( specif ) avec : etiq l'étiquette de l'instruction format , placée dans les colonnes 1 à 5 ;

- 112 -

5. Mise en forme des données en Fortran 77 -

specif le spécificateur de format : un ou plusieurs descripteurs répétables ou non-répétables, fixant la manière de traiter les données. Ces descripteurs sont principalement :

- une ou plusieurs barres obliques, - un ou plusieurs champs d'édition, - un ou plusieurs séparateurs de champs. Une instruction format est toujours étiquetée et cette étiquette sert de lien entre les instructions read , print ou write et le descripteur d'édition. C'est une instruction non exécutable. Les parenthèses font partie de la syntaxe de l'instruction. 5.1.1.2 DESCRIPTEURS D'ÉDITION La mise en forme des données est essentielle dans les opérations d'entrée / sortie. Sans spécifi-cations d'édition, le compilateur ne peut pas lire ou écrire les données codées (non binaires) de tous les types existants. Le langage prévoit plusieurs possibilités de donner les spécifications d'édition : 1. au moyen d'une instruction format . 2. au moyen d'une expression de type character : constante, variable ou tableau de ce type.

L'expression doit être placée entre parenthèses et apostrophes. 3. au moyen d'une variable de type integer assignée à une étiquette d'une instruction format par l'inter-

médiaire de l'instruction assign . 4. au moyen de l'astérisque (*) pour une mise en forme directe en fonction du type de variable à traiter. L'instruction format est la méthode classique de description de la mise en forme. Elle a comme incon-vénient d'utiliser une étiquette. Dans ce cours, nous employons plutôt la seconde méthode, l'expression de type character. Les programmeurs utilisant jusqu'à maintenant format s'habitueront très rapidement à ce mode de programmation. Dans la mise en forme, nous distinguerons deux groupes de spécificateurs ou descripteurs : 1. les spécifications de traitement des données, 2. les spécifications de mise en page. Les premières régissent la transmission des éléments de la liste dans les instructions d'entrée / sortie, les secondes apparaissent dans les spécifications de mise en forme. Le traitement des variables dépend essentiellement de leur type : integer , real , double precision , complex ou character . 5.1.1.3 MISE À LA LIGNE OU À LA PAGE Le premier caractère de chaque enregistrement transmis remplit le rôle de caractère de contrôle pour la mise à la ligne ou à la page. Les caractères réservés à cette fonction sont donnés dans le tableau 5.1 . Tout autre caractère situé dans la première colonne est considéré comme un espace. Le caractère de contrôle n'est pas imprimé. Il est recommandé de prévoir un espace comme premier caractère de contrôle dans l'écriture d'un texte ou le symbole x avant toute impression d'une variable numérique. Exemple :

* * Avec l'instruction format sous VAX-11 * write (*,110) 110 format (' Donnez le degré du polynôme : ',$) * * Sans instruction format * write (*,'(1x,a,f15.5)')

- 113 -


+ 'Le résultat est : ',avar

Tableau 5.1 CARACTÈRES DE CONTRÔLE DE MISE À LA LIGNE

- Caractère - Effet

(espace) 0 (zéro) 1 (un) + (plus) $ (dollar) \

avance d'une ligne . avance de deux lignes . saute au haut de la page suivante . reste sur la ligne, donc permet d'écrire sur la même ligne (Hors norme ANSI). supprime le retour de chariot (VAX-11 et DOMAIN). supprime le retour de chariot (MS-FORTRAN).

5.1.1.4 CODES DE LECTURE OU D'ÉCRITURE Une des difficultés initiales dans l'écriture des instructions d'entrée / sortie est le choix correct du code pour la lecture ou l'écriture des diverses composantes. Le tableau 5.2 donne les codes généraux.

Tableau 5.2 CODES GÉNÉRAUX D'ÉDITION DES DONNÉES

Code - Forme - Utilisation

A

D

E

F

G

H

I

L

A[c]

Dc.d

Ec.d

Fc.d

Gc.d

nHc…c

Ic[.m]

Lc

Edition de caractères ou de constantes Hollerith

Edition d'une valeur réelle ou en double précision, la lettre D servant à exprimer la puissance de 10

Edition d'une valeur réelle ou en double précision, la lettre E servant à exprimer la puissance de 10

Edition d'une valeur réelle ou en double précision, en virgule fixe

Edition d'une valeur réelle ou en double précision, en lecture comme code F en écriture soit code F ou E selon valeur

Transfert d'une constante Hollerith entre un enregistrement externe et une place en mémoire vive

Edition d'une valeur entière

Edition d'une valeur logique

O Z

Oc[.m] Zc[.m]

Edition d'une valeur octale Edition d'une valeur hexadécimale

c nombre de colonnes utilisées en lecture ou écriture d nombre de caractères à droite du point décimal m nombre de caractères écrits dans le champ d'édition

- 114 -


Les termes d, c et m doivent être des constantes entières non signées, les dimensions maximales étant limitées suivant les possibilités physiques des périphériques ou de l'ordinateur. Les possibilités d'emploi de ces codes seront décrites sous 5.1.2 . 5.1.1.5 MISE EN FORME DES DONNÉES Les descripteurs de mise en forme sont citées dans le tableau 5.3 , les uns à la suite des autres. Ils seront présentés sous 5.1.3 .

Tableau 5.3 DESCRIPTEURS DE MISE EN FORME DES DONNÉES

Code Forme Fonction de la commande

BN BZ

KP

T TL TR

SP SS

X

BN BZ

kP

Tc TLc TRc

SP SS

nX / :

‘,,,’

Ignore les blancs d'un champ numérique en lecture. Considère les blancs comme des zéros en lecture.

Facteur de multiplication des descripteurs F,E,D . ou G

Tabulateur absolu. Tabulateur relatif à gauche. Tabulateur relatif à droite.

Ecrit le signe + ou - en écriture. Supprime l'écriture du signe +

Avance de n colonnes dans l'enregistrement. Commence un nouvel enregistrement. Termine le contrôle si la liste est épuisée. Ecriture d'un ou de plusieurs caractères.

c nombre de colonnes

5.1.2 DESCRIPTEURS DE CONSTANTES ET VARIABLES Les descripteurs de données numériques et alphanumériques spécifient la configuration de la lecture et de l'écriture : type, nombre de colonnes, nombre de chiffres après le point décimal. Si le compilateur ne peut écrire une donnée par suite de manque de place, il remplace la donnée par des astérisques. 5.1.2.1 DESCRIPTEUR POUR TYPE INTEGER Les données décimale de type integer doivent être décrites par la forme suivante :

Ic [.m ] avec : I ou i descripteur des constantes ou variables de type integer , integer*2 ou integer*4 , c nombre de colonnes réservé au champ, m paramètre optionnel permettant de fixer le nombre minimal de chiffres à écrire. Les règles de lecture ou d'écriture des entiers sont :

- 115 -


1. le descripteur I c spécifie que c caractères doivent être lus ou écrits à partir d'une liste; 2. le cadrage du nombre de caractères se fait à droite du champ d'écriture; 3. suppressions des zéros à gauche du premier chiffre significatif; en lecture avec l'option BZ , les

blancs sont traités comme des zéros; 4. si le nombre entier est plus grand que c caractères, compte tenu du signe, il y a écriture de c asté-

risques dans le champ. Exemples : Impression par I5 , le caractère ^ indiquant un blanc Valeur à imprimer Affichage

4289 ------> ^4289 46 ------> ^^^46 - 67 ------> ^^-67 -30456 ------> ***** 0 ------> ^^^^0 L'impression avec le symbole optionnel m permet d'éliminer les zéros avec le descripteur Ic .0 ou à placer un ou plusieurs zéros devant le nombre à écrire, le nombre de chiffres devant être m : Exemple : Soit à écrire 3 par les descripteurs : Format : I4.2 ------> 2 chiffres ^^03 I4.4 ------> 4 chiffres 0003 5.1.2.2 DESCRIPTEUR G POUR TYPE REAL Ce descripteur permet de traiter des grandeurs numériques de type real, en simple et double pré-cision, au moyen du spécificateur :

Gc .d avec : G ou g : descripteur pour les constantes et variables numériques non entières, C nombre de colonnes réservé à la lecture ou à l'écriture, D nombre de chiffres après le point décimal.

Tableau 5.4 ÉCRITURE D'UNE DONNÉE RÉELLE PAR G

Valeur du nombre (rn) Spécificateur

rn < 0.1 0.1 < rn < 1.0 1.0 < rn < 10.0 10d-2 < rn < 10d-1 10d-1 < rn < 10d rn > 10d

Ec.d F(c-4).d,^^^^ F(c-4)(d-1),^^^^ F(c-4).1,^^^^ F(c-4).0,^^^^ Ec.d

^^^^ représente 4 blancs

- 116 -


La représentation d'une donnée réelle dépend de son ordre de grandeur. En lecture, le champ G est identique aux champs F, E ou D. En écriture, le descripteur spécifie que la valeur numérique doit s'écrire soit en virgule fixe, soit en virgule flottante, arrondie à d décimales et justifiée à droite, le champ d'impres-sion ayant c colonnes. Le tableau 5.4 donne les divers modes de représentation. Le signe + n'est pas imprimé et le nombre de colonnes réservé à l'impression doit être suffisant pour écrire le signe - , le point décimal, l'exposant d'où : c plus grand ou égal à d + 7. Exemple d'affichage avec descripteur G (MS-FORTRAN):

* * Exemple 21 * Affichage au moyen du descripteur G * program exem21 integer i real*4 anomb data anomb /0.0001234567/ * write (*,'(//,15x,a,//,2(5x,a,/),//,15x,a,10x,a,/)') + 'ECRITURE AU MOYEN DU DESCRIPTEUR G', + 'Le nombre initial vaut : 0.0001234567', + 'Il est multiplié chaque fois par 10', + 'Numéro','Valeur' * do 10 i=0,20 write (*,'(15x,i5,10x,g14.7)') i,anomb if (mod(i,5) .eq. 0) write (*,*) anomb=10.0*anomb 10 continue * end Résultat de l'exécution du programme (MS-FORTRAN) ECRITURE AU MOYEN DU DESCRIPTEUR G

Le nombre initial vaut : 0.0001234567 Il est multiplié chaque fois par 10

Numéro Valeur

0 .1234567E-03 1 .1234567E-02 ............................ 8 12345.67 9 123456.7 ............................ 20 .1234567E+17

- 117 -


5.1.2.3 DESCRIPTEUR F POUR TYPE REAL Le descripteur F permet de traiter des grandeurs numériques en simple ou double précision, au moyen du spécificateur :

Fc .d avec : F ou f : descripteur en virgule fixe pour données numériques non entières, c nombre de colonnes réservé à la lecture ou l'écriture, d nombre de chiffres placés après le point décimal. Le descripteur F est très avantageux lorsqu'il s'agit d'imprimer des résultats devant rester en colonnes et alignés. Le nombre de colonnes prévu doit être suffisant pour placer le signe et le point décimal qui est toujours écrit. Le signe + n'est pas écrit et un champ numérique vide en lecture est traité comme un zéro. Le nombre de colonnes doit être égal ou supérieur à c +1 , c + 2 si le nombre est négatif. Les règles complémentaires de l'impression sont : 1. Le cadrage de l'impression est à droite du champ imprimé, 2. En revenant vers la gauche, il y a d chiffres, le point décimal, les chiffres précédant le point décimal

et le signe - si la valeur est négative. Exemples d'impression avec le format F12.5 Nombre à afficher Valeur affichée 0,0000012345 0.00000 0,0123456 0.01235 12.345678 12.34568 -12345.678 -12345.67800 12345678.0 ************ Le dernier exemple montre que si l'on choisit le descripteur F, il faut prévoir suffisamment de colonnes pour imprimer les résultats les plus grands et le premier exemple suffisamment de chiffres après le point décimal pour imprimer des valeurs différentes de zéro. 5.1.2.4 DESCRIPTEURS E ET D POUR TYPE REAL Les descripteurs E et D permettent de traiter des grandeurs numériques en simple ou double précision dans la forme puissance de 10. La configuration se compose de deux parties : la mantisse et l'exposant séparés par la lettre E ou D . La syntaxe est :

Ec .d [Ee ] Dc .d avec : c le nombre de colonnes réservé à la lecture ou l'écriture de la donnée numérique non entière, d le nombre de chiffres significatifs placés après le point décimal, e paramètre optionnel fixant le nombre de chiffres de l'exposant, en introduisant des zéros si

nécessaire. En opération d'entrée, les descripteurs E et D permettent de lire des données avec ou sans exposant de 10. En opération de sortie, les descripteurs écrivent toujours les données numériques en exposant de 10. Les deux descripteurs sont identiques à part la présence de la lettre E ou D . Ils imposent :

- 118 -


1. la valeur numérique réelle ou double précision doit être transférée sous la forme d'une mantisse et d'une puissance de 10, arrondie après d décimales et justifiée à droite du champ;

2. Si la valeur ne remplit pas les c colonnes prévues, des blancs sont insérés en complément à gauche; 3. Si la valeur à écrire dépasse c caractères, le champ entier est rempli d'astérisques; 4. le signe - est imprimé si la valeur est négative, suivi d'un zéro, du point décimal, de d chiffres

significatifs, de la lettre E ou D , du signe de l'exposant et de l'exposant à deux chiffres. Le signe + n'est pas imprimé, à moins de l'utilisation du code SP.

5. Le nombre de colonnes à prévoir dépend du nombre de chiffres significatifs désirés dans la mantisse. Il faut que :

c >= d + 7 si l'exposant est à deux chiffres, c >= d + 8 si l'exposant est à trois chiffres. 6. l'écriture de la lettre E est à réserver aux données de type real , real*4 , la lettre D aux données de

type double precision ou real*8 . Exemple : * * Exemple 22 * Affichage au moyen des descripteurs F et D * program exem22 integer i real*4 anomb data anomb /0.9876543E-06/ * write (*,'(//,15x,a,//,2(5x,a,/),//,10x,a,2(7x,a),/)') + 'ECRITURE AU MOYEN DES DESCRIPTEURS F ET D', + 'Le nombre initial est 0.0000009876543', + 'Le nombre est multiplié chaque fois par 10', + 'Numéro','Forme F18.7','Forme E18.7' * do 10 i=0,20 write (*,'(10x,i5,1x,f18.7,e18.7)') i,anomb,anomb if (mod(i,5) .eq. 0) write (*,*) anomb=10.0*anomb 10 continue * end Résultat de l'exécution du programme (MS-FORTRAN) ECRITURE AU MOYEN DES DESCRIPTEURS F ET D Le nombre initial vaut : 0.0000009876543 Il est multiplié chaque fois par 10 Numéro Forme F18.7 Forme E18.7 0 .0000010 .9876543E-06 1 .0000099 .9876543E-05 2 .0000988 .9876543E-04 ........................................ 8 98.7654300 .9876543E+02 ........................................ 20 ****************** .9876544E+14

- 119 -


L'avantage essentiel du descripteur E est de pouvoir fixer le nombre de chiffres significatifs et de con-server pour toutes les valeurs numériques à peu près la même précision relative. Elle est par contre plus difficile à lire. Elle peut s'utiliser également pour imprimer les parties réelle et imaginaire d'un nombre complexe. 5.1.2.5 FACTEUR DE MULTIPLICATION Le facteur de multiplication peut s'introduire avec les spécificateurs de valeurs réelles : G , F , E et D . Ce facteur optionnel se place devant le descripteur sous la forme d'un entier positif ou négatif. Les syn-taxes modifiées de ces descripteurs deviennent :

k P [ n ] Gc .d k P [ n ] Fc .d k P [ n ] Ec .d [Ee ] k P [ n ] Dc .d avec : k facteur entier positif ou négatif, P symbole pour l'opération de multiplication, n facteur de répétition du descripteur, optionnel, entier positif non signé, indiquant au compilateur

d'utiliser n fois le descripteur de mise en forme. Le descripteur k P indique le facteur à prévoir pour les descripteurs cités jusqu'au prochain descrip-

teur k P . Au départ de chaque instruction d'entrée / sortie, le facteur est initialisé à zéro. En lecture ou en écriture, la représentation externe de la donnée numérique est égale à celle de sa

représentation interne multipliée par 10**k . Le facteur n'a pas d'effet si la valeur est exprimée avec un exposant. En écriture avec les descripteurs E ou D , le compilateur multiplie la valeur par 10*k et sous-trait k de l'exposant, ce qui change la représentation externe, mais pas du tout la valeur interne de la donnée. En écriture avec le descripteur G , le compilateur utilise le descripteur F ou E , dépendant de la valeur absolue de la donnée à afficher ou imprimer. Exemple classique d'utilisation de ce descripteur : valeur en % : write (*,'(10x,a,2pf5.3,a)') 'Le taux est : ',taux,' %' Pour taux = 0.0575 , le programme affiche : Le taux est : 5.75 % 5.1.2.6 DESCRIPTEUR L POUR TYPE LOGICAL Le descripteur L ou I est utilisé pour lire et écrire les données logiques; sa syntaxe est :

Lc avec : L ou l : descripteur d'une donnée de type logical, C le nombre de colonnes réservé à la lecture ou à l'écriture. L'élément de la liste d'entrée ou de sortie doit être de type logical. Les règles applicables sont : 1. en lecture :

- 120 -


1.1 le descripteur Lc indique que c caractères doivent être lus; 1.2 si le premier caractère du champ, différent du caractère espace, est la lettre T, t, .T ou .t , la valeur

logique .true. est assignée à l'élément de la liste; 1.3 si le premier caractère du champ, différent de l'espace, est la lettre F, f, .F ou .f , la valeur logique

.false. est assignée à l'élément de la liste, 1.4 tout autre caractère provoque une erreur en lecture. 2. en écriture : 2.1 le descripteur Lc indique que soit la lettre T soit la lettre F doivent se placer dans le champ à c

colonnes, lettre justifiée à droite et précédée de c -1 espaces. Exemple : Format Valeur logique Affichage

l5 .true. ^^^^T l1 .false. F 5.1.2.7 DESCRIPTEUR A POUR CARACTÈRES Le descripteur A ou a s'utilise pour lire ou écrire des chaînes de caractères, écrire des constantes Hollerith. La syntaxe est :

A [c ] avec : A ou a : descripteur pour chaînes de caractères, C le nombre de colonnes réservé à la lecture ou l'écriture de la chaîne de caractères. 1. Lecture : Le descripteur transfère c caractères de l'enregistrement externe et l'affecte à l'élément correspon-dant de la liste. Le nombre de caractères pouvant être transféré dépend du type de l'élément de la liste : variable ou chaîne de caractère -----> 1 caractère par octet. Si c est plus grand que le nombre de carac-tères transférables dans l'élément de la liste, il y a troncature à gauche. Si c est plus petit que le nombre de caractères transférables, la chaîne de caractères est justifiée à gauche. 2. Ecriture Le descripteur spécifie que le contenu de l'élément de la liste doit être transféré vers l'extérieur sous forme d'un champ de c caractères. Si c est plus grand que la chaîne, il y a justification à droite et com-plément par des espaces à gauche. Si le champ est trop court, il y a troncature à droite. Si c est absent du descripteur, la longueur du champ est ajustable et va dépendre du nombre d'oc-tets contenu dans l'élément de la liste ou dans la donnée : chaînes de caractères ou sous-chaînes. Pour lire un caractère ou une chaîne, il faut utiliser le descripteur a plutôt que devoir écrire la chaîne de carac-tères encadrée d'apostrophes. Montrons comment entrer un texte au clavier : introduire la date et l'afficher afin de contrôler la jus-tesse de la frappe au clavier.

- 121 -


* * Exemple 23 * Affichage de la date et de l'heure * program exem23 integer*2 annee,heu,jour,min,sec character*10 mois * write (*,'(//,15x,a,//,5x,a,$)') + 'INTRODUCTION DE LA DATE ET DE L''HEURE', + 'Donnez le jour : ' read *, jour write (*,'(12x,a,$)') 'le mois en toutes lettres : ' read (*,'(a)') mois write (*,'(12x,a,$)') 'l''année : ' read *, annee write (*,'(/,5x,a,/,12x,a,$)') + 'Donnez l''heure : ','heure, minute et seconde : ' read *, heu,min,sec * write (*,'(//,10x,a,i3,1x,a,1x,i5,/,10x,a,3(i3,1x,a),//)') + 'La date introduite est : ',jour,mois,annee, + 'L''heure actuelle est : ',heu,'h',min,'min',sec,'s' * end Résultat de l'exécution du programme INTRODUCTION DE LA DATE ET DE L'HEURE

Donnez le jour : 25 le mois en toutes lettres : novembre l'année : 1988

Donnez l'heure : heure, minute et seconde : 13 27 38

La date introduite est : 25 novembre 1988 L'heure actuelle est : 13 h 27 min 38 s 5.1.2.8 DESCRIPTEUR H POUR CHAÎNES DE CARACTÈRES Nous avons déjà décrit la constante Hollerith sous 2.2.8 . Le langage FORTRAN supporte l'édition de chaînes de caractères encadrées d'apostrophes et hors norme, afin de conserver la compatibilité avec les versions précédentes du langage, le descripteur H , ces deux modes étant applicables en écriture. La syntaxe du descripteur H est :

n Hchaine avec : n nombre de caractères à transférer, chaine une suite de caractères ASCII.

- 122 -


Le descripteur H ne peut plus s'utiliser dans une instruction read . Les deux instructions suivantes sont équivalentes : write (*,'(a)') ' abcdefgh' write (*,'(9H abcdefgh)') 5.1.2.9 DESCRIPTEUR Z POUR CONSTANTES HEXADÉCIMALES L'édition d'une donnée sous forme hexadécimale s'effectue au moyen du descripteur Z . La syntaxe hors norme est :

Zc [.m ] avec : c nombre de colonnes réservé à la lecture ou à l'écriture, entier positif non signé, indiquant aussi le

nombre maximal de caractères. Les données sont justifiées à droite dans le champ. M paramètre optionnel permettant de fixer le nombre minimal de caractères à écrire, si nécessaire, avec

complément de zéros (pas reconnu par tous les compilateurs). En lecture, l'enregistrement, écrit sous forme d'une constante, ne peut contenir que les chiffres de 0 à 9 et les lettres A (a) à F (f) , mais ni signe, ni point décimal, ni exposant. Un champ vide attribue zéro à la variable. En écriture, le descripteur Z transfère la valeur hexadécimale justifiée à droite dans le champ. C'est la suite de bits contenu dans l'élément qui est transformée en valeur externe hexadécimale. VAX-11 permet également la transcription des valeurs octales par Oc[.m] obéissant aux mêmes règles de syn-taxe. * * Exemple 24 * Affichage décimal et hexadécimal * program exem24 integer*4 i,ifin,ifois,incr,init,nombre * write (*,'(//,15x,a,//,5x,a,$)') + 'AFFICHAGE DECIMAL ET HEXADECIMAL', + 'Donnez le nombre entier inférieur : ' read *, init write (*,'(12x,a,$)') 'le nombre entier supérieur : ' read *, ifin write (*,'(12x,a,$)') 'l''incrément de calcul : ' read *, incr * ifois = (ifin-init)/incr write (*,'(//,12x,a,13x,a,9x,a,/)') + 'Numéro','Décimal','Hexadécimal' do i=0,ifois nombre = init+i*incr write (*,'(1x,15x,i3,i20,12x,z8)') i,nombre,nombre if (mod (i,5) .eq. 0) print * end do * end

- 123 -


Résultat de l'exécution du programme (MS-FORTRAN) AFFICHAGE DECIMAL ET HEXADECIMAL Donnez le nombre entier inférieur : 10 le nombre entier supérieur : 200 l'incrément de calcul : 10

Numéro Décimal Hexadecimal

0 10 0000000A 1 20 00000014

.............................................. 20 200 000000C8 5.1.3 DESCRIPTEURS DE MISE EN PAGE Les descripteurs de mise en page sont cités dans le tableau général sous 5.1.1.5 et leurs fonctions principales. Décrivons brièvement ces principaux descripteurs en donnant leur utilisation. 5.1.3.1 SAUT DE COLONNES : DESCRIPTEUR X La configuration du descripteur de saut de colonnes est simplement :

n X avec : n une constante entière non signée indiquant le nombre de colonnes à sauter en lecture ou en écriture. En lecture, n colonnes sont ignorées, tandis qu'en écriture, n colonnes sont remplies de blancs ou d'espaces. Exemple : write (*,'(/,4x,a,9x,a,7x,a,8x,a,15x,a,/)') + 'No','x','Flèche','Angle','Moment' Cette instruction, employée en écriture, permet de placer les têtes de colonne. Le premier caractère affiché, dans le cas particulier N , va se placer dans la colonne 4 , 3 espaces le précédant car le premier x sert de caractère de contrôle. Nous avons placé chaque fois une virgule entre chaque descripteur d'édi-tion, ce caractère pouvant être omis si la syntaxe reste encore claire. Afin d'éviter l'affichage d'erreurs à la compilation ou l'exécution, nous introduirons chaque fois la virgule comme séparateur. 5.1.3.2 SAUT D'ENREGISTREMENT : DESCRIPTEUR / Le descripteur de saut d'enregistrement, constitué par la barre oblique, a pour effet de passer à l'en-registrement suivant. Au début ou à la fin d'une instruction de mise en forme, il fait sauter autant de cartes (en lecture) ou de lignes (en écriture) qu'il y a de barres obliques. A l'intérieur de l'instruction d'écriture, ce symbole fait passer à la ligne suivante et saute n-1 lignes pour n barres obliques. Exemple : write (*.'(//,8x,a,//,2(13x,a,f15.3,/))')

- 124 -


+ 'Réactions des appuis :','Réaction gauche : ',reacb, + 'Réaction droite : ',reacc Cette instruction d'écriture produit les effets suivants : 1. saut de deux lignes, 2. saut de 7 colonnes et écriture de : Reactions des appuis : 3. saut d'une ligne et passage à la ligne suivante, 4. saut de 12 colonnes et écriture de : Reaction gauche et impression du résultat en virgule fixe dans 15

colonnes dont trois sont réservées aux décimales, 5. passage à la ligne suivante, 6. saut de 12 colonnes et écriture de : Reaction droite et impression du résultat en virgule fixe dans 15

colonnes dont trois sont réservées aux décimales (répétition du descripteur), 7. saut d'une ligne, car fin de l'écriture selon mise en forme. 5.1.3.3 TABULATEUR 1. Tabulation absolue Le descripteur T sert de tabulateur et fixe la position absolue du pointeur dans la colonne spécifiée, la première colonne étant numérotée 1 . La syntaxe est :

Tc avec : T ou t : descripteur du tabulateur absolu, c une constante entière non signée indiquant la position c à partir du début de l'enregistrement. Cette

valeur doit être égale ou supérieure à 1 , mais pas supérieure au nombre de caractères alloué à l'en-registrement.

En lecture, le tabulateur absolu indique la position du début de lecture. En écriture, le transfert externe de la valeur s'effectue à partir de la position c dans l'enregistrement. Exemple : write (*,'(/,t20,a,t40,a,t60,a,/)') + 'Colonne 1','Colonne 2','Colonne 3' Cette instruction a pour effet : 1. sauter une ligne 2. écrire Colonne 1 à partir de la colonne 20, 3. écrire Colonne 2 à partir de la colonne 40, 4. écrire Colonne 3 à partir de la colonne 60. 2. Tabulation relative Les deux descripteurs complémentaires TLc et TRc sont à disposition : tabulation relative à gauche ou à droite. Le déplacement relatif du pointeur s'effectue par la syntaxe :

TLc TRc avec : T ou t : pour le descripteur de tabulation, L ou l : pour une tabulation relative à gauche, R ou r : pour une tabulation relative à droite,

- 125 -


c constante entière non signée indiquant au pointeur le nombre de colonnes à se déplacer vers la gau-che ou vers la droite à partir de la position courante. La constante doit être égale ou supérieure à 1 . En déplacement à gauche, si c est plus grand ou égal à la position actuelle du pointeur, le dépla-cement s'effectue jusqu'au premier caractère de l'enregistrement. En déplacement à droite, c ne doit pas dépasser le nombre de caractères de l'enregistrement.

5.1.3.4 INTERRUPTION DU CONTRÔLE DE LA TRANSMISSION Le descripteur de fin de contrôle, constitué par le double point : , interrompt le contrôle de l'exploration de l'instruction de mise en forme. S'il reste des éléments dans la liste d'entrée / sortie, ce descripteur n'a aucun effet. Exemple d'un petit programme partiel avec instructions format : write (*,160) 21 write (*,170) 47 160 format (6x,'Nombre 1 = ',i2,5x,'Nombre 2 = ',i2) 170 format (6x,'Nombre 3 = ',i2,:,5x,'Nombre 4 = ',i2) Ces instructions permettent d'afficher les constantes à l'écran sous la forme :

Nombre 1 = 21 Nombre 2 = Nombre 3 = 47 Dans le premier cas, l'exploration de format s'effectue jusqu'à la lecture du second texte, la seconde valeur à afficher ne figurant pas dans la liste à écrire. Dans le second cas, l'exploration de format se ter-mine au double point, car la constante numérique 47 est la dernière entité à traiter dans la liste. 5.1.3.5 RÉPÉTITION DES DESCRIPTEURS Si plusieurs descripteurs successifs ou simplement plusieurs groupes de descripteurs consécutifs sont identiques, il est possible de simplifier l'écriture des descripteurs en introduisant un facteur de répé-tition. Les descripteurs I , F , G , E , D , A , L peuvent être précédés d'un facteur qui est une constante entière non signée. Exemples :

5i4 correspond à I4,I4,I4,I4,I4 4f12.4 correspond à F12.4,F12.4,F12.4,F12.4 3(2x,f10.3) correspond à 2X,F10.3,2X,F10.3,2X,F10.3 5('* *') correspond à '* ** ** ** ** *' Une liste de descripteurs, appelée groupe de descripteurs, est placée entre parenthèses et peut être précédée d'un facteur de répétition. 5.1.3.6 EXPLORATION DE LA MISE EN FORME La configuration de la mise en forme est explorée de gauche à droite en synchronisme avec la liste d'entrée / sortie. Les spécifications de mise en page, y compris les spécificateurs de chaînes de carac-tères, sont traitées par l'instruction format ou par la constante chaînes de caractères, placées entre apostrophes, écrite dans l'instruction write . Le nombre d'éléments de la liste peut différer du nombre de spécifications de traitement des entités dans l'instruction de mise en forme.

- 126 -


S l'instruction de mise en forme contient des groupes de descripteurs entre parenthèses, la réexplo-ation de l'instruction commence à la parenthèse gauche symétrique de l'avant dernière parenthèse droite dans cette instruction. Il est possible de mettre un groupe de descripteurs entre parenthèses dans le seul but de diriger vers une nouvelle exploration de l'instruction, ce qui permet de transmettre des com-mentaires et plusieurs lignes de nombres avec un seul groupe de descripteurs. Attention ! Si l'instruction de mise en forme ne suffit pas à l'exploration de la liste à traiter, le pointeur d'explora-tion se repositionne au début de l'instruction. Exemple : Dans cet exemple, nous voulons créer un tableau simple de dimensions géométriques pour des sur-faces circulaires et afficher ce tableau au moyen d'une seule instruction de mise en forme. * * Exemple 25 * Calcul des dimensions géométriques dans le cercle avec * affichage d'un tableau de valeurs * program exem25 integer*2 i,j real*4 a(46,4),pi,r,rmax,rmin * parameter (pi = 3.141593) data rmin,rmax /10.0,100.0/ * write (*,'(//,15x,a,//,2(10x,a,f6.1,/),///)') + 'CALCUL DES DIMENSIONS DANS LE CERCLE', + 'Rayon minimal des cercles = ',rmin, + 'Rayon maximal des cercles = ',rmax * do i=1,46 r = rmin+(i-1)*2.0 a(i,1) = r a(i,2) = pi*r a(i,3) = 2.0*pi*r a(i,4) = pi*r*r end do * write (*,'(9x,a,//,t10,a,t17,a,t26,a,t45,a,t62,a,//, + 5(9x,i2,f10.1,3f15.4,/))') + 'TABLE DES DIMENSIONS GEOMETRIQUES POUR SECTIONS CIRCULAIRES', + 'No','Rayon','Demi-cercle','Cercle','Aire', + (i-1,(a(i,j),j=1,4),i=1,46) * end L'avant dernière parenthèse dans l'instruction write , située sur la seconde ligne, contient un groupe de descripteurs : 5(9x,i2,f10,1,3f15.4,/) Le facteur de répétition est 5, placé devant la parenthèse gauche. Le groupe de descripteurs est par-couru cinq fois. Lorsque les cinq parcours sont effectués, il y a remise à la ligne en fin d'exploration et

- 127 -


nouvelle exploration du groupe de descripteurs du fait de la présence des divers éléments dans la liste et de l'expression parenthésée dans l'instruction de mise en forme. Résultat de l'exécution du programme CALCUL DES DIMENSIONS DANS LE CERCLE

Rayon minimal des cercles = 10.0 Rayon maximal des cercles = 100.0

TABLE DES DIMENSIONS GEOMETRIQUES POUR SECTIONS CIRCULAIRES

No Rayon Demi-cercle Cercle Aire

0 10.0 31.4159 62.8319 314.1593 1 12.0 37.6991 75.3982 452.3894 ......................................................... 45 100.0 314.1593 628.3186 31415.9300 5.1.4 POSSIBILITÉS COMPLÉMENTAIRES Les quelques renseignements complémentaires de ce sous-chapitre permettent de résoudre certains problèmes rencontrés dans la programmation courante, en particulier dans la gestion des entrées / sorties au clavier et à l'écran. 5.1.4.1 CHOIX DE LA REPONSE Nous avons utilisé à plusieurs occasions des instructions de lecture permettant de traiter des ques-tions et réponses. En mode interactif, il arrive souvent de devoir répondre par oui ou par non à une ques-tion apparaissant sur l'écran afin d'effectuer un choix entre deux possibilités de poursuite du programme. La structure générale de cette partie de programme est donnée dans l'exemple partiel ci-après. ..... character*1 rep logical ltest ..... write (*,'(6x,a,$)') 'Désirez-vous continuer (o/n) ? ' read (*,'(a1)') rep ltest = (rep .eq. 'o') .or. (rep .eq. 'O') if (ltest) then * -----> action si réponse = oui else * -----> action si réponse = non end if Dans cet exemple, le descripteur de lecture a1 pour la variable rep de type character*1 évite de devoir placer la réponse frappée au clavier encadrée d'apostrophes. Il est inadmissible d'exiger de la part de l'utilisateur l'écriture de tout texte alphanumérique entre apostrophes.

- 128 -


5.1.4.2 ÉCRITURE DE LA MISE EN FORME La plupart des exemples proposés dans le texte utilise les instructions de lecture read et d'écriture write avec une mise en forme des données dans l'instruction elle-même et non dans une instruction format . Le langage FORTRAN autorise une mise en forme des données par l'intermédiaire d'une expres-sion de type character : constante , variable ou élément de tableau de ce type. Cette configuration doit se programmer entre parenthèses, encadrée d'apostrophes. Une troisième possibilité de spécification est donnée par l'instruction assign associée à une variable de type integer*4 , ce qui permet de remplacer l'étiquette dans l'instruction par l'identificateur de la varia-ble entière. Nous n'utiliserons pas ce mode de programmation afin d'éviter l'emploi d'étiquettes. 5.1.4.3 ÉDITION DES ENTITÉS COMPLEXES La lecture et l'écriture des valeurs complexes sont à réaliser au moyen des descripteurs pour type real : F , E , D ou G . En lecture, les deux champs pour grandeur complexe sont lus et les deux parties, réelle et imaginaire, sont transférées vers l'élément de la liste. En écriture, les deux composantes de la grandeur complexe sont transmises l'une après l'autre, sans ponctuation, à moins de la prévoir expres-sément dans l'instruction de mise en forme. Exemple : Valeurs à transmettre Format Représentation externe

2.345678, 7.8912345 2f8.5 2.34568 3.89123 53789.333, 47.89432 e9.2,' , ',f7.3 0.54E+06 , 47.894 5.1.4.4 CHAMP DE DESCRIPTEURS PAR DÉFAUT Certains compilateurs, mais pas tous, prévoient une lecture ou une écriture des valeurs de la liste au moyen de formats pris par défaut. Cette opération intervient lorsque les descripteurs I , Z , L , F , E , G ou A sont cités sans indiquer le nombre de colonnes prévu pour la lecture ou l'écriture. La mise en forme par défaut dépend d'une part du type de variable à traiter et du descripteur lui-même, voir les manuels des constructeurs. 1. Lecture directe des données La lecture directe de données se signale par la présence de l'astérisque dans l'instruction de lecture. Exemple : real*4 b ..... read *, a,b Les données de type integer , real , double precision , complex ou logical doivent s'écrire dans la forme imposée par le type. Les données doivent être séparées par la virgule ou par un blanc. Les don-nées de type real , mais entières, peuvent s'écrire sans le point décimal tandis que le point décimal est interdit dans l'écriture d'une donnée de type integer . Pour les données de type complex , les parties réelle et imaginaire sont à placer entre parenthèses, séparées par la virgule, mais sans blancs. Pour les données de type character , la chaîne à introduire doit être écrite encadrée d'apostrophes, méthode vivement déconseillée. Exemple :

- 129 -


à éviter absolument programmation recommandée

character*20 chaine character*20 chaine ..... ..... read *, chaine read (*,'(a)') chaine 2. Eciture de données L'écriture de données, sans mise en forme, ne présente pas de difficulté pour les types integer , real , character , le compilateur introduisant des blancs par défaut. Dans un programme un peu évolué, l'intro-duction de la mise en forme est beaucoup plus efficace, la seule difficulté à résoudre intervenant lorsque le champ du descripteur est insuffisant pour écrire la valeur. Dans ce cas, utilisez le descripteur G . 5.1.4.5 LECTURE DES CARTES PERFORÉES Bien que les cartes perforées s'utilisent de moins en moins, il est intéressant de connaître les règles de lecture. Les cartes perforées représentent un support d'information en dur et s'emploient encore pour introduire les valeurs initiales dans un programme. Les espaces ou les blancs, représentés ci-dessous par le caractère ^, dans le champ d'une valeur numérique sont considérés comme des zéros. Exemples : Carte Résultat en f7.3 Résultat en i7

^^54321 54.321 54321 ^-1^3^7 -10.307 -10307 ^^^^^2^ 0.020 20 ^^^^^^^ 0.000 0 Le point décimal ou la forme exponentielle perforé dans la carte ont priorité sur l'emplacement du point indiqué dans le descripteur de format et la mantisse peut être placée n'importe où dans le champ, l'éventuel exposant, en tant qu' integer doit être cadré à droite. Il est donc recommandé de perforer le point décimal pour toutes les constantes de type real, même pour celles qui sont entière, ce qui dispense de cadrer. Le plus simple est d'utiliser le descripteur G , qui convient également aux constantes en double précision. La subdivision de la carte à 80 colonnes en huit champs de dix colonnes est très commode en pratique. 5.1.4.6 SPÉCIFICATEURS VARIABLES DE MISE EN FORME Dans un programme général, l'introduction de descripteurs à configuration fixe est parfois difficile à accepter en écriture. Il est possible de s'affranchir de cette contrainte au moyen de spécificateurs varia-bles. La mise en forme désirée sera placée dans un tableau de chaînes de caractères et sera introduite par l'instruction write . Une autre possibilité consiste à composer la chaîne de caractère à partir de spécifica-teurs concaténés.

- 130 -


* * Exemple 26 * Utilisation de plusieurs mises en forme * program exem26 character*40 forme(2) real*4 valeur * * Mise en forme enregistrée dans deux instructions data * Chaque élément de forme(2) représente une mise en forme * data forme(1) /'(10x,''Nombre négatif = '',f16.3)'/ data forme(2) /'(10x,''Nombre positif = '',f16.3)'/ data valeur /1.0/ * write (*,'(//,15x,a,//,5x,a,/)') + 'INTRODUCTION DE NOMBRES REELS QUELCONQUES', + 'Terminez en introduisant 0 (zéro)' * do while (valeur .ne. 0.0) write (*,'(/,5x,a,$)') 'Donnez un nombre réel : ' read *, valeur if (valeur .ge. 0.0) then write (*,forme(2)) valeur else write (*,forme(1)) valeur end if end do * end Résultat de l'exécution du programme INTRODUCTION DE NOMBRES REELS QUELCONQUES

Terminez en introduisant 0 (zéro) Donnez un nombre réel : 12.34567

Nombre positif = 12.346 Donnez un nombre réel : -12.34567

Nombre négatif = -12.346

- 131 -


5.2 LECTURE ET ÉCRITURE Dans le langage FORTRAN , l'instruction de lecture est read , l'instruction d'écriture est print ou write. Ces trois instructions interviennent soit directement dans les opérations au terminal ou dans le déroulement du programme, soit sur les divers types de fichiers. Dans ce sous-chapitre, nous traitons les opérations d'entrée et de sortie sur la console de l'utilisateur. 5.2.1 LISTES D'ENTRÉE ET DE SORTIE La liste des entités d'une instruction de lecture ou d'écriture contient les identificateurs de variables simples, de variables de tableaux, d'éléments de tableau et de chaînes ou sous-chaînes de caractères. En écriture, la liste peut aussi citer des constantes. La liste est toujours transmise totalement. 5.2.1.1 LISTE SIMPLE La liste peut contenir une ou plusieurs variables simples, un ou plusieurs tableaux, un ou plusieurs éléments de tableaux, une ou plusieurs constantes en écriture. Elle peut se composer d'un ensemble de listes simples. Si l'identificateur d'une variable indicée figure sans ses indices, tout le tableau est transmis, dans l'ordre de rangement des éléments en mémoire, c'est-à-dire que le premier indice varie d'abord et le plus souvent, puis le second, etc. Exemple en écriture et lecture : write (*,'(10x,4i6)') i,k(2),4,n(7) read *, i,j,table(i,j) Ici, i , k (2) , 4 et n (7) sont des éléments simples dans la liste à écrire sous la forme i6 . Dans la se-conde instruction, la lecture des deux valeurs pour i et j permet de fixer la position de l'élément table (i ,j ) en mémoire. Les valeurs affectées aux premières variables de la liste peuvent s'utiliser dans les élé-ments suivants. 5.2.1.2 LISTE À BOUCLE IMPLICITE La boucle implicite est une simplification dans la programmation d'une structure répétitive do ... end do ou do ... continue . Cette possibilité est employée principalement : 1. pour transmettre une partie d'un tableau dans un ordre déterminé des éléments en faisant appel aux

indices, 2. pour transmettre tous les éléments d'un tableau dans un ordre différent de celui de rangement en mé-

moire, comme par exemple par lignes et non par colonnes. La forme générale de l'instruction est :

( liste , i = e1 , e2 [ , e3 ] ... ) avec : liste une liste d'éléments en entrée ou en sortie, i une variable de boucle de type integer , e1,e2,e3 les paramètres de boucle, identiques à ceux de la boucle do ... fondamentale.

- 132 -


La variable de boucle et les paramètres e1, e2 et e3 remplissent les mêmes fonctions que dans l'instruction do ... , voir sous 3.3.1 . Les éléments de la liste peuvent faire référence à la variable de boucle, mais ne doivent en aucun cas la modifier. Les règles à observer, dans la composition de cette structure, sont : 1. introduire une paire de parenthèses pour chaque boucle, même unique, 2. la variable de boucle la plus intérieure varie d'abord et le plus souvent, 3. une virgule doit précéder chaque variable de boucle, 4. les expressions contenant ou non la ou les variables de boucle sont admissibles comme indice, 5. chaque liste simple précédant une variable de boucle peut contenir plusieurs variables ou éléments, 6. l'imbrication de plusieurs boucles est possible. Exemples : write (*,'(5x,3f12.5)') (a,b,c,i=1,3) write (*,'(3(5x,3f12.5))') a,b,c,a,b,c,a,b,c Ces deux instructions sont équivalentes. write (*,'(1x,f14.5)') ((table(i,j),j=1,10),i=1,11,2) Cette même instruction devrait se programmer au moyen de la boucle do ... comme suit :

do i=1,11,2 do j=1,10 write (*,'(1x,f14.5)') table(i,j) end do end do On voit immédiatement la simplification d'écriture de l'instruction et la possibilité de nouvelle explo-ration de l'instruction de mise en forme. read *, (p(i),(q(i,j),j=1,10),i=1,5) Cette instruction lit les éléments p (1),q (1,1), q (1,2), ... , q (1,10) avant d'incrémenter i à la valeur 2 . Le seule inconvénient de cette structure est de devoir entrer 55 éléments au clavier sans texte intermé-diaire. La boucle implicite en lecture est donc réservée au transfert de données d'un fichier externe ou interne plutôt qu'aux entrées au clavier. print *, (i,i=1,30) Cette instruction écrit au terminal tous les nombres entiers de 1 à 30 avec la mise en forme par défaut. 5.2.2 LECTURE PAR L'INSTRUCTION READ La lecture de données s'effectue par l'introduction de l'instruction read , cette instruction permettant l'entrée d'entités à partir du clavier ou de périphériques connectés à l'ordinateur. 5.2.2.1 SYNTAXE DE L'INSTRUCTION L'instruction de lecture, à partir du terminal, transmet les valeurs introduites au clavier, après pression sur la touche <RET>, vers la mémoire de l'unité centrale avec transformation en représentation interne. La syntaxe de l'instruction est :

- 133 -


read fmt [ , ilist ] read (clist ) [ilist ] avec : fmt descripteur de mise en forme dans le mode direct de lecture. Ilist liste des variables vers lesquelles les grandeurs introduites au clavier, séparées par l'espace ou la

virgule, seront transmises et affectées. Ces entités sont : des variables simples ou de tableaux, des éléments de tableaux, des variables ou des sous-chaînes de caractères, mais pas des cons-tantes.

clist liste de contrôle, placée entre parenthèses, pouvant contenir dans le cas de lecture de données : - unité : numéro de l'unité de lecture : -----> * pour entrée en mode direct,

5 dans la plupart des implémentations FORTRAN, - fmt : le descripteur de mise en forme de la lecture : -----> * pour entrée de valeurs de type integer ou real, descripteur de lecture pour types character et logical. 5.2.2.2 EXEMPLES DE LECTURE Lecture de valeurs en mode conversationnel : read *, a,b,c read (5,*) a,b,c La seconde variante s'introduit surtout si la donnée à lire nécessite un descripteur de type : types character, logical. Un texte doit toujours accompagner l'introduction d'une donnée en mode interactif car s'il est possible d'affecter une constante entière, sans point décimal à une variable de type real , l'affectation d'une constante réelle à une variable de type integer n'est pas acceptée pendant l'exécution du programme. Le pointeur de ligne attend l'introduction de toutes les valeurs de la liste. Il est recommandé de prévoir l'intro-duction d'une seule valeur par instruction read ... . L'affectation d'une chaîne de caractères à une variable numérique n'est plus autorisée avec FOR-TRAN-77. La plupart des fabricants ont conservé cette possibilité de lire des caractères et de les affecter à des variables numériques afin de ne pas devoir modifier les programmes existants. Ce mode de pro-grammation permet de loger un caractère par octet, comme le montre l'exemple ci-dessous. Mode FORTRAN-IV Mode FORTRAN-77

real*4 ville(5) character*20 ville ..... ..... read (*,'(5a4)') ville read (*,'(a)') ville La variable indicée ville (5), de type integer*4 , peut contenir 20 caractères ASCII puisqu'elle com-prend cinq éléments et chaque élément occupe quatre octets. En déclarant le descripteur de lecture 5a4 , l'affectation est possible dans la plupart des versions actuelles. 5.2.3 ÉCRITURE DE DONNÉES Deux instructions sont à disposition pour écrire des données : print pour l'affichage au terminal et write pour toute écriture de données dans n'importe quel périphérique de l'ordinateur ou fichier.

- 134 -


5.2.3.1 SYNTAXE DE L'INSTRUCTION Les instructions print et write transmettent, de la mémoire vive de l'ordinateur, les données des entités citées dans la liste de sortie, conformément aux descripteurs implicites ou explicites corres-pondants, vers le périphérique spécifié. Les syntaxes sont :

print fmt [ , olist ] write (clist ) [olist ] avec : fmt le descripteur de mise en forme qui peut être : - une étiquette d'une instruction format, - une variable de type integer*4 assignée à une étiquette d'une instruction format, - une expression ou élément de tableau de type character, - un astérisque * indiquant le mode direct par défaut. olist liste des entités à écrire selon mise en forme spécifiée. Les entités peuvent être : des identificateurs

de variables simples ou de tableaux, des éléments de tableaux, des chaînes ou des sous-chaînes de caractères, des expressions y compris des constantes, des listes do ... implicites.

clist liste de contrôle, placée entre parenthèses, pouvant contenir, dans le cas d'écriture de données : - unité : numéro de l'unité : * pour le mode d'affichage au terminal, descripteur usuel de l'écran, habituellement 6 (ou aussi 5) selon l'implémentation du langage; - fmt : la mise en forme des données : * pour un ou des descripteurs par défaut, un descripteur de mise en forme constitué par : - une étiquette d'une instruction format, - une variable de type integer*4 assignée à une étiquette d'une instruction format, - une expression de type character (mode de programmation utilisé). 5.2.3.2 EXEMPLES D'ÉCRITURE 1. Sans mise en forme de l'écriture Il est possible d'écrire des variables et des constantes en mode direct, la mise en forme s'effectuant par défaut : print *, 'Donnez le numéro de l''enregistrement :' read *, numero 2. Avec descripteur de mise en forme L'instruction fait mention du numéro de l'unité logique ou de l'astérisque et cite la mise en forme des données. write (*,'(10x,a,$)') 'Donnez le numéro de l''enregistrement : ' read *,numero 3. Avec les instructions print (ou write) et format La même instruction pourrait s'écrire : print 110 read *, numero 110 format (10x,'Donnez le numéro de l''enregistrement : ',$)

- 135 -


Un exemple de programmation de ce type est donné dans l'exemple 6 avec une variable de type integer*4 assignée à une étiquette. La méthode classique de programmation avec l'instruction write serait write (6,110) read (*,*) numero 110 format (10x,'Donnez le numéro de l''enregistrement : ',$) 5.2.4 EXEMPLE DE PROGRAMME Ce programme calcule la réponse harmonique d'une fonction de transfert d'un élément donnée sous forme d'une fraction algébrique en p :

G(p) = N(p) / D(p) avec : N(p) polynôme du numérateur en p, jusqu'au 32ième degré, D(p) polynôme du dénominateur en p, jusqu'au 32ième degré. Dans le cas de la réponse harmonique, l'expression peut s'écrire :

G(j ω) = N(j ω) / D(j ω) , avec : j = (-1.0)0,5, ω = pulsation. Le programme utilise des variables complexes et la méthode de Horner, ici une fonction polynomiale en complexe, pour évaluer les deux polynômes. * * Exemple 27 * Calcul de la réponse harmonique d'un élément linéaire * donné par sa fonction de transfert: G(p) = N(p)/D(p) * program exem27 integer i,ipn,m,n,np complex horner,omega,pol real*4 fac,om,ommax,ommin,phi,x,y real*4 a(0:32),b(0:32),res(0:100,5) intrinsic aimag,alog10,atan2,cmplx,real,sqrt external lectur,horner * * Fonction-formule pour trouver le module * rayon(x,y)=sqrt(x*x+y*y) * write (*,'(//,18x,a,///,2(5x,a,/),/,3(5x,a,/),/,5x,a,$)') + 'REPONSE HARMONIQUE D''UN ELEMENT QUELCONQUE', + 'La fonction de transfert est donnée sous forme d''une fraction', + 'algébrique en p : G(p) = N(p)/D(p)', + 'Les coefficients des deux polynômes sont à donner comme suit :', + 'a(n), a(n-1), a(n-2), ... , a(2), a(1), a(0)', + 'b(m), b(m-1), b(m-2), ... , b(2), b(1), b(0)', + 'Donnez le degré n du polynôme du numérateur : '

- 136 -


read *,n write (*,'(12x,a,$)') 'le degré m du polynôme du dénominateur : ' read *,m * write (*,'(/,20x,a,$)') 'Coefficients du numérateur' call lectur (a,n) write (*,'(/,20x,a,$)') 'Coefficients du dénominateur' call lectur (b,m) * write (*,'(/,5x,a,$)') 'Donnez omega minimal : ' read *, ommin write (*,'(12x,a,$)') 'omega maximal : ' read *, ommax write (*,'(12x,a,$)') + 'le nombre de points par puissance de 10 : ' read *, np * * Initialisation des grandeurs * fac = 10.0**(1.0/np) ipn = (alog10(ommax)-alog10(ommin))*np om = ommin if (n .eq. 0) then a(1) = a(0) a(0) = 0.0 n = 1 end if if (m .eq. 0) then b(1) = b(0) b(0) = 0.0 m = 1 end if * * Calcul de la réponse harmonique * do i=0,ipn omega = cmplx(0.0,om) pol = horner(a,n,omega)/horner(b,m,omega) res(i,1) = om res(i,2) = real(pol) res(i,3) = aimag(pol) res(i,4) = rayon(res(i,2),res(i,3)) res(i,5) = 57.29578*atan2(res(i,3),res(i,2)) om = om*fac end do * * Affichage des résultats dans un tableau * write (*,'(///,16x,a,//,3x,a,7x,a,10x,a,10x,a,7x,a,6x,a,//, + 5(1x,i4,f12.4,2f15.5,e15.5,f13.4,/))') + 'REPONSE HARMONIQUE EN FONCTION DE LA PULSATION', + 'No','omega','GRéel','GImag','Module','Angle en °',

- 137 -


+ (i,(res(i,j),j=1,5),i=0,ipn) * end * ********************************************************** * Sous-programme de lecture des coefficients * subroutine lectur (a,n) integer i,n real*4 a(0:n) * do i=0,n write (*,'(10x,a,i3,a,$)') + 'Coefficient indice ',n-i,' = ' read *, a(i) end do end * ********************************************************** * Fonction calculant la valeur complexe du polynôme * complex function horner (a,n,om) integer i,n real*4 a(0:n) complex om,prov intrinsic cmplx * prov = cmplx(a(0)) do i=1,n prov = prov*om+a(i) end do horner = prov end Résultat de l'exécution du programme (Seulement les résultats) REPONSE HARMONIQUE EN FONCTION DE LA PULSATION No omega GRéel GImag Module Angle en ° 0 0.0100 9.95590 -0.66705 0.99782E+01 -3.8331 1 0.0112 9.95590 -0.74759 0.99726E+01 -4.2992 ...................................................................... etc.

- 138 -

CHAPITRE 6

LES FICHIERS FORTRAN Les programmes écrits par le programmeur sont conservés sur l'un des disques durs de l'ordina-teur ou éventuellement sur des bandes magnétiques ou sur des disques de type CD, les instructions étant stockées sous forme d'une suite de caractères ASCII . Les programmes sont placés dans des enregistrements appelés fichier, ayant un identificateur conforme aux règles d'écriture en vigueur dans le système d'exploitation, pouvant se lire à l'écran ou s'écrire sur une imprimante externe au moyen d'une des commandes appropriées au système d'exploitation. Par contre, les programmes compilés et exécutables, c'est-à-dire traduits en langage machine, constitués par l'ensemble des programme et sous-programmes, sont stockés sur les mêmes supports codés sous forme binaire. Ils ne peuvent pas s'afficher à l'écran ou s'écrire sur une imprimante car le codage binaire ne correspond pas aux caractères du code ASCII . Ces trois types de fichiers : source, objet et exécutable, sont placés dans des enregistrements identifiables par un nom de fichier suivi habituellement d'une extension. Le choix de l'extension, séparée par le point du nom de fichier, est imposé soit par le compilateur, soit par le système d'exploitation. Dans ce chapitre, nous désignerons fichier codé, un fichier composé de caractères ASCII lisibles à l'écran ou sur l'imprimante et un fichier binaire, un fichier constitué d'octets non lisibles à l'extérieur de l'exécution du programme. Le langage FORTRAN reconnaît les fichiers suivants : 1. fichiers séquentiels : dans ce type de fichier, l'accès en écriture ou en lecture s'effectue depuis le

début jusqu'à la fin du fichier. 2. fichiers à accès direct : dans ce type de fichier, l'accès en écriture et en lecture est sélectif et

s'effectue par l'intermédiaire d'un numéro d'ordre. 3. fichiers internes : le transfert des données s'effectue entre des variables définies dans le pro-

gramme. La composante de base d'un fichier est l'enregistrement. Un enregistrement est une suite de don-nées numériques et/ou alphanumériques. Les fichiers séquentiel ou direct représentent des enre-gistrements externes à la mémoire vive de l'ordinateur. Ils ne peuvent pas être écrits ou lus dans le programme sans passer par une unité intermédiaire constituée par une mémoire tampon. La mémoire tampon permet de stocker provisoirement des informations transmises du disque vers le programme ou dans le sens inverse afin de ne pas interrompre le flux des données qui ne peut se réaliser que par secteurs sur les disques durs.

6.1 GÉNÉRALITÉS SUR LES FICHIERS La lecture et l'écriture de données dans un fichier se réalise par les deux instructions : 1. lecture de données dans le fichier : Instruction read ... 2. écriture de données dans le fichier : Instruction write ... Ces deux instructions sont accompagnées d'un certain nombre de clauses ou options facilitant le transfert et le déroulement des opérations.

- 139 -


6.1.1 DESCRIPTION DES GENRES DE FICHIERS 6.1.1.1 ENREGISTREMENTS Chaque instruction d'entrée / sortie transfère un enregistrement. Les instructions codées ASCII ou binaires autorisent le transfert d'enregistrements supplémentaires. Si une instruction d'entrée n'utilise pas tout les champs de données de l'enregistrement, les champs en surplus sont ignorés. Si l'instruc-tion d'entrée exige plus de champs que ceux contenus dans l'enregistrement, une erreur apparaît et si l'entrée est codée, tous les champs sont lus comme des espaces. Ces fonctionnalités peuvent dépen-dre du compilateur. Si l'instruction de sortie attend d'écrire plus de champs que ce que contient l'enregistrement, une erreur intervient. Si l'instruction de sortie transfère moins de données que le nombre imposé par un enregistrement à longueur fixe, l'enregistrement est remplit d'espaces s'il est codé, ou de zéro s'il est binaire. 6.1.1.2 FICHIERS EXTERNES Un fichier est donc une collection d'enregistrements organisés dans un ordre déterminé et formant une unité. L'organisation du fichier est déterminée lors de sa création par une instruction d'ouverture du fichier. Il existe deux genres de fichiers externes : séquentiel et direct. Les fichiers sont normale-ment stockés sur les disques de l'ordinateur ou éventuellement sur un autre support de données. Les unités périphériques comme les terminaux, les imprimantes de lignes, les traceurs, les lecteurs de cartes ou de bandes perforées sont traitées comme des fichiers séquentiels. 1. Organisation séquentielle Les enregistrements d'un fichier à accès séquentiel sont organisés en séquences dites physiques, chaque enregistrement, à part le premier, possède un enregistrement le précédent, et chaque enre-gistrement, sauf le dernier, présente un enregistrement qui le suit. L'ordre dans lequel les enregis-trements se trouvent dans le fichier est engendré lors de l'écriture du fichier. Les enregistrements peuvent être de tailles différentes. 2. Organisation directe Les enregistrements d'un fichier à accès direct possèdent tous la même longueur et sont ordon-nés en séquences physiques. Ils sont numérotés à partir de 1 pour le premier enregistrement jusqu'à n pour le dernier. La longueur des enregistrements se donne dans l'opération d'ouverture du fichier. Chaque enregistrement possède son numéro d'ordre, attribué lors de l'écriture. L'organisation à accès direct autorise l'écriture d'enregistrements dans un ordre quelconque. Il n'est pas possible de retirer un enregistrement de l'ensemble, mais par contre il est possible de remplacer les données existantes par de nouvelles valeurs. 6.1.1.3 FICHIERS INTERNES Un fichier interne désigne une place mémoire facilitant les opérations d'entrée / sortie. Il s'utilise avec les instructions de lecture et d'écriture codée, éliminant l'emploi des instructions hors norme ANSI encode et decode valables dans la version FORTRAN-IV . Un fichier interne consiste en une variable, élément de tableau ou sous-chaîne, tous de type character . Le fichier comprend exactement un seul enregistrement, sa longueur étant celle de la variable ou de l'élément de type character. Si le fichier interne comprend un tableau d'éléments de type character, ce fichier se compose d'un ensemble d'enregistrements, chaque enregistrement correspondant à un élément simple de la variable indicée. L'ordre des enregistrements est fixé par l'ordre de l'indice des éléments. Le pointeur est toujours positionné au début du premier enregis-trement à l'exécution d'une instruction d'entrée / sortie.

- 140 -

- 6. Utilisation des fichiers en Fortran 77 -

6.1.1.4 MODES D'ACCÈS On appelle mode d'accès au fichier la méthode utilisée par le programme pour stocker ou retrouver un enregistrement dans ce fichier. 1. Accès séquentiel Un accès séquentiel signifie que les enregistrements sont traités en séquence, du début à la fin du fichier. Il est possible d'accéder à un fichier direct en accès séquentiel. Dans ce cas, l'accès a lieu dans l'ordre croissant des numéros d'enregistrement. 2. Accès direct Un accès direct signifie que le programme spécifie l'ordre de traitement par un numéro d'enregis-trement pour chaque instruction d'entrée / sortie. Pour pouvoir accéder directement à un fichier séquentiel, il faut que tous les enregistrements aient même longueur donc même nombre d'octets. 6.1.2 CLAUSES Le langage FORTRAN autorise de nombreuses clauses dans les instructions d'entrée / sortie. Ce sous-chapitre les décrit par ordre alphabétique, certaines clauses étant applicables seulement à une ou quelques instructions. Dans la description des instructions utilisées pour le traitement des fichiers, les clauses applicables à ces instructions seront citées avec leurs diverses possibilités d'affectations. Les instructions pouvant contenir une ou plusieurs clauses sont : backspace close endfile inquire open print read rewind write

Tableau 6.1 CLAUSES DES INSTRUCTIONS D'ENTRÉE / SORTIE

Clause Fonction de la clause

access = mode blank = blanc direct = dir end = etiq err = etiq

spécifie le mode d'accès séquentiel ou direct spécifie le traitement des blancs comme 0 ou esp. contrôle le mode d'accès direct ou non transfère le déroulement à etiq en fin de fichier transfère le déroulement à étiq en cas d'erreur

exist = lexis file = nomfich form = fcode formatted = fmtd fmt = dfmt

contrôle l'existance ou non d'un fichier spécifie le nom externe du fichier décrit le codage du fichier contrôle si le codage est ASCII ou non descripteur de mise en forme

iostat = istat name = nom named = lnom nextrec = next number = num

retient la condition d'E/S, = 0 si correcte décrit le nom complet du champ contrôle la présence du nom du fichier retient le numéro du dernier enregistrement + 1 spécifie le numéro de l'unité logique

opened = lopen rec = recnum recl = rlong sequential = seq status = stat

contrôle l'ouverture du fichier numéro de l'enregistrement à traiter longueur de l'enregistrement décrit si l'accès séquentiel est correct ou non décrit si le fichier existe en mode adopté

unformatted = unf unit = ifid unit = uni

décrit si le transfert binaire est autorisé spécifie le fichier interne d'E/S spécifie une unité externe à connecter avec le fichier

- 141 -


6.1.2.1 MODE D'ACCÈS : ACCESS La clause permettant de fixer le mode d'accès au fichier présente la syntaxe suivante :

access = mode avec : mode une constante chaîne de caractères fixant le mode d'accès : 'sequential' mode d'accès séquentiel, 'direct' mode d'accès direct. La constante doit être placée entre apostrophes et peut se remplacer par une expression de type character à droite du caractère = . La clause par défaut est 'sequential' . Lors de la création d'un nouveau fichier, le mode d'accès est fixé soit pas défaut, soit par la clause explicite. Pour faciliter la lecture et la compréhension d'un programme comportant de nombreuses ouvertures de fichier, il est recommandé de citer cette clause dans l'instruction d'ouverture. Si la clause access est utilisée dans l'instruction inquire , mode doit être une variable ou un élé-ment de tableau de type character, car le compilateur affecte à cette variable la valeur 'sequential' ou 'direct' . Le mode d'accès doit être conservé à toute ouverture d'un fichier. Certains compilateurs admettent de lire un fichier créé en accès direct par une ouverture en mode d'accès séquentiel. 6.1.2.2 TRAITEMENT DES BLANCS : BLANK Le traitement des blancs ou espaces dans les opérations d'entrée / sortie peut se fixer par la clause de syntaxe :

blank = blanc avec : blanc une constante de type caracter , soit : 'null' les blancs sont ignorés; c'est l'option par défaut, 'zero' les blancs sont considérés comme des zéros. Avec l'instruction inquire , blanc doit être une variable ou un élément de tableau de type charac-ter. Le compilateur affecte à cette entité l'une des deux constantes : 'null' ou 'zero' . Si la clause est : form = 'unformatted' , alors la clause blank est indéfinie dans les opérations d'E/S . 6.1.2.3 CONTRÔLE DU MODE D'ACCÈS : DIRECT Dans l'instruction inquire, la clause direct permet de contrôler si le mode d'accès au fichier est direct ou non. La syntaxe est :

direct = dir avec : dir variable ou élément de tableau de type character. FORTRAN affecte à cette entité l'une des

valeurs suivantes : 'yes' si le mode d'accès direct est autorisé, 'no' si le mode d'accès direct est interdit, 'unknown' si le mode d'accès ne peut pas être trouvé. 6.1.2.4 FIN DE FICHIER : END La clause end permet de transférer le déroulement du programme vers une instruction exécu-table étiquetée dans la même unité de programme, lorsque la marque de fin de fichier est atteinte. La syntaxe est :

end = etiq

- 142 -


avec : etiq une constante ou une expression entière positive correspondant à une étiquette existante

dans l'unité de programme. Exemple : read (8,'(a)',end = 100) ctexte ..... 100 close (8) La clause end est interdite dans une instruction de lecture read ... contenant la clause : rec = attribut d'entrée / sortie. 6.1.2.5 CONTRÔLE DES ERREURS : ERR La clause err transfère le déroulement du programme vers une instruction exécutable étiquetée dans la même unité de programme lorsqu'une opération d'entrée / sortie provoque une erreur quel-conque. La syntaxe est :

err = etiq avec : etiq étiquette d'une instruction exécutable permettant de continuer le programme ou de traiter

éventuellement la cause de l'erreur. Si la clause err est présente dans l'instruction d'entrée / sortie et qu'une erreur intervient, le pro-gramme continue à l'instruction portant l'étiquette spécifiée. Si par contre, cette clause est absente, le programme s'arrête et affiche un message d'erreur. 6.1.2.6 EXISTANCE D'UN FICHIER : EXIST La clause exist , utilisée dans l'instruction inquire , permet de trouver l'existence ou non d'un fichier ou d'une unité. La syntaxe est :

exist = lexis avec : lexis une variable de type logical. FORTRAN affecte à cette variable : .true. si le fichier ou l'unité existe, .false. si le fichier ou l'unité n'existe pas. 6.1.2.7 NOM DU FICHIER : FILE Pour obtenir la liaison entre les instruction open , inquire et le fichier, il est nécessaire de citer le nom complet du fichier externe avec toutes ses caractéristiques au moyen de la clause :

file = nomfich avec nomfich nom complet du fichier externe, conforme aux règles imposées par le système d'ex-

ploitation : chemin , identificateur et extension compris. Le nom doit être encadré d'apostrophes.

Si le nom de fichier est placé dans une variable ou un élément de tableau de type character, cette entité peut être placée à droite du caractère = . Dans la plupart des cas, le nom du fichier est une constante chaîne de caractères. Les compilateurs de mini-ordinateurs admettent par exemple un identificateur par défaut.

- 143 -


6.1.2.8 NATURE DE L'ENREGISTREMENT : FORM L'enregistrement peut être constitué par une suite de caractères codés selon ASCII ou par une suite d'octets sous forme binaire. La syntaxe de la clause fixant la nature de l'enregistrement est :

form = fcode avec : fcode une constante de type chaîne de caractères dans l'instruction open : 'formatted' codé ASCII, 'unformatted' codé binaire. La constante doit être encadrée d'apostrophes et peut se remplacer par une variable ou un élé-ment de tableau de type character, affecté de l'une des deux valeurs alphanumériques. Pour un fichier à accès séquentiel, la forme de l'enregistrement est 'formatted' par défaut tandis que pour un fichier à accès direct, la forme de l'enregistrement est 'unformatted' par défaut. Lors de l'accès à un fichier existant, la clause par défaut ou explicitement déclarée dans l'instruc-tion d'ouverture doit correspondre exactement à la nature du codage utilisé précédemment pour ce fichier. L'introduction du code ASCII nécessite toujours une opération de transformation de la repré-sentation interne en représentation externe et vice versa. Ces opérations consomment du temps machine et provoquent très souvent une perte de précision numérique. De plus, l'utilisation d'une mise en forme d'une grandeur numérique occupe plus de place en mémoire que le nombre d'octets alloué à la représentation interne. Avant d'introduire les options par défaut, surtout pour l'accès séquentiel, il est recommandé de conserver la structure binaire aux données d'un fichier utilisé seulement dans un ou plusieurs programmes FORTRAN. Si par contre, le fichier doit être lisible au niveau du système d'exploitation ou que ce fichier ait été écrit au moyen d'un éditeur de texte, il faut introduire le codage ASCII, soit la clause 'formatted'. Si la clause form est utilisée dans l'instruction inquire , fcode doit être une variable ou un élé-ment de tableau de type character. FORTRAN affecte à cette variable soit 'formatted', soit 'unformatted' suivant le codage utilisé. 6.1.2.9 CONTRÔLE DU CODAGE La clause formatted utilisée dans l'instruction inquire permet de déceler le genre de codage du fichier. La syntaxe est :

formatted = fmtd avec : fmtd une variable ou un élément de tableau de type character. Le compilateur FORTRAN affecte à

cette entité : 'yes' si une E/S codée ASCII est autorisée, 'no' si une E/S codée ASCII est défendue, 'unknown' si le compilateur ne peut pas déceler si une E/S codée ASCII est permise ou

non sur ce fichier. 6.1.2.10 MISE EN FORME : FMT La clause permettant de fixer la mise en forme de l'enregistrement s'écrit par la syntaxe suivante :

fmt = dfmt avec : dfmt un des choix suivants : - une étiquette d'une instruction format, - une variable de type integer*4 assignée à l'étiquette d'un format,

- une constante de type character, décrivant la mise en forme, la chaîne devant être encadrée d'apostrophes,

- 144 -


- l'identificateur d'un élément de tableau ou d'une variable de type character contenant la chaîne de mise en forme,

- un astérisque * spécifiant la mise en forme directe. Si la clause de mise en forme est la seconde clause de l'instruction d'E/S, le mot-clé fmt = est optionnel. Dans ce cours, nous utilisons essentiellement la constante de type character. 6.1.2.11 ÉTAT DES ENTRÉES - SORTIES : IOSTAT La clause iostat , applicable à toutes les instructions d'E/S, provoque l'affectation d'un code d'état à la variable istat selon la syntaxe :

iostat = istat avec : istat une variable ou un élément de tableau de type integer*4 prenant la valeur : 0 si l'opération d'E/S s'est effectuée correctement, ... une valeur négative si une fin de fichier est atteinte, ... une valeur positive si une erreur est intervenue dans l'opération d'E/S. La valeur retournée dépend du processeur et de la présence ou non de fichiers de traitement des erreurs, du système d'exploitation et de l'implémentation du langage. 6.1.2.12 CONTRÔLE DU NOM : NAME ET NAMED La clause name permet de récupérer le nom complet du fichier au moyen de l'instruction inquire, la syntaxe étant :

name = nom avec : nom une variable ou un élément de tableau de type character. FORTRAN affecte le nom complet

du fichier à cette entité. La clause named permet de détecter si le fichier connecté à l'unité logique possède un nom ou pas de nom, la syntaxe étant :

named = lnom avec : lnom une variable ou un élément de tableau de type logical. FORTRAN affecte la valeur .true. si le

fichier est nommé, .false. si le fichier ne l'est pas. 6.1.2.13 NUMÉRO D'ENREGISTREMENT : NEXTREC La clause nextrec , utilisée avec l'instruction inquire, permet de trouver le numéro du prochain enregistrement. La syntaxe est :

nextrec = next avec : next une variable ou un élément de tableau de type integer. FORTRAN affecte le numéro du

dernier enregistrement lu + 1 à cette entité, mais sans effectuer d'opération d'E/S. En accès séquentiel, l'entité reste indéterminée.

- 145 -


6.1.2.14 NUMÉRO D'UNITÉ LOGIQUE La clause number, utilisée dans l'instruction inquire, permet de retrouver le numéro attribuée à une unité logique, la syntaxe étant :

number = num avec : num une variable ou un élément de tableau de type integer. FORTRAN affecte à cette entité le

numéro de l'unité logique connectée au fichier. 6.1.2.15 CONTRÔLE DE L'OUVERTURE : OPENED La clause opened , utilisée dans l'instruction inquire , permet de contrôler si le fichier est ouvert ou non. La syntaxe est :

opened = lopen avec : lopen variable ou élément de tableau de type logical. FORTRAN affecte la valeur .true. si le fichier

est ouvert, la valeur .false. dans le cas contraire. 6.1.2.16 SPÉCIFICATION DU NUMÉRO D'ENREGISTEMENT : REC La clause rec permet de donner le numéro de l'enregistrement pour la lecture et l'écriture. Elle s'introduit seulement dans le mode d'accès direct dans les instruction read ... et write ... . La syntaxe est :

rec = recnum avec : recnum une expression de type integer , y compris une constante positive. Cette clause ne peut pas s'introduire dans une opération d'E/S en mode séquentiel, ni dans les fichiers internes. 6.1.2.17 LONGUEUR DE L'ENREGISTREMENT : RECL La clause recl fixe la longueur de l'enregistrement dans les instructions open et inquire. La syntaxe est :

recl = rlong avec : rlong une expression entière positive spécifiant la longueur en octets de l'enregistrement. Pour les fichiers séquentiels, rlong doit être la longueur maximale des enregistrements. Pour un nouveau fichier à accès direct, rlong doit être égal à la longueur de l'enregistrement + 1 octet. Pour un fichier existant à accès direct, rlong peut être égal à la longueur des enregistrements existants. Habituellement, pour un fichier binaire, rlong est exprimé en octets ou éventuellement en mots. Avec l'instruction inquire , rlong est une variable ou un élément de tableau de type integer , FORTRAN affectant à cette variable la longueur de l'enregistrement utilisé en accès direct. 6.1.2.18 CONTRÔLE DU MODE SÉQUENTIEL : SEQUENTIAL La clause sequential , utilisée dans l'instruction inquire , permet de déterminer si le mode d'ac-cès est séquentiel ou non. La syntaxe est :

- 146 -


sequential = seq avec : seq une variable ou élément de tableau de type character. FORTRAN affecte : 'yes' si l'accès séquentiel est autorisé, 'no' si l'accès séquentiel est défendu, 'unknown' si l'accès séquentiel ne peut pas se trouver sur ce fichier. 6.1.2.19 ÉTAT DU FICHIER : STATUS La clause status décrit l'état du fichier que l'on veut ouvrir ou fermer. La syntaxe est :

status = stat avec : stat une constante de type chaîne de caractères, soit lors de l'ouverture par open : 'old' le fichier existe à l'ouverture, 'new' un nouveau fichier est créé, 'scratch' un nouveau fichier sera créé et sera détruit lors de sa fermeture, 'unknown' crée un nouveau fichier s'il n'existe pas lors de l'ouverture, utilise le fichier existant

s'il est présent sur le disque. La clause par défaut est 'unknown' ; pour cette clause, le programme essaie la variante 'old' et si le fichier n'existe pas, il adopte la variante 'new'. Utilisez cette clause s'il y a des doutes sur la pré-sence d'un fichier. Certains compilateurs reconnaissent la clause 'append' (hors norme ANSI) qui, à l'ouverture du fichier, est identique à 'unknown', mais place le pointeur d'enregistrement sur la fin du fichier. Les autres clauses hors norme ANSI sont : 'write' , 'readonly' et 'overwrite' . Dans l'instruction close , la clause par défaut est 'keep' à moins d'une ouverture avec l'option 'scratch' . Il est possible de remplacer la constante par une variable ou un élément de tableau de type character affecté d'une des options. 6.1.2.20 CONTRÔLE DU CODAGE : UNFORMATTED La clause unformatted utilisée avec l'instruction inquire permet de déceler le genre de codage du fichier. La syntaxe est :

unformatted = unf avec : unf une variable ou un élément de tableau de type character. FORTRAN affecte : 'yes' si une E/S binaire est autorisée, 'no' si une E/S binaire n'est pas autorisée, 'unknown' si le compilateur ne peut pas déterminer si une E/S binaire est permise ou non. 6.1.2.21 SPÉCIFICATION DE L'UNITÉ : UNIT La clause unit fixe le numéro de l'unité logique connectée au fichier et cette clause est la plus uti-lisée dans les instructions d'E/S . Elle est exigée dans la plupart des instructions, à part dans inquire. La syntaxe est :

[unit = ] uni | ifid avec : uni une constante, une variable ou une expression de type entier identifiant l'unité. Il est recom-

mandé de ne pas dépasser 99 , la valeur maximale dépendant du compilateur. Les unités 5, 6 et 7 sont généralement réservées aux unités préconnectées avec la console :

- 147 -


5 pour la lecture : écran, 6 pour l'écriture : le clavier.

En complément, l'astérisque * peut remplacer le numéro pour se connecter sur les fichiers standards d'entrée - sortie. Le mot-clé unit peut être omis si uni est la première clause dans la liste de l'instruction.

Dans l'instruction read , l'entrée standard est l'unité par défaut si le numéro de l'unité n'est pas spécifié. Dans l'instruction print * , l'unité standard est l'unité par défaut. Dans ces cas, il n'est pas nécessaire d'ouvrir les fichiers standards. La variable ou la chaîne de caractères ifid est l'identificateur d'un fichier interne valable seule-ment avec les instructions read et write . Dans ce cas, ces instructions doivent contenir une spéci-fication de mise en forme. 6.1.3 OUVERTURE DES FICHIERS Pour relier un fichier externe à la mémoire centrale, il est nécessaire de fixer, par programmation, les points suivants : 1. le nom du fichier externe, conforme aux règles imposées par le système d'exploitation, situé sur le

disque dur de l'ordinateur. 2. l'identificateur de la mémoire tampon servant au transfert des données entre le disque et le pro-

gramme : ce nom est constitué par un numéro de type integer. Cette unité porte la désignation d'unité logique.

3. la nature de l'accès : accès séquentiel ou accès direct. 4. la nature du codage de l'information stockée dans le fichier : codée ASCII ou binaire. 5. la nature du fichier : nouveau fichier ou fichier déjà existant sur le disque, fichier à conserver ou à

détruire après édition ou modification. 6. des spécifications complémentaires concernant la lecture ou l'écriture, la longueur des enregis-

trements, le traitement des erreurs ou de la fin de fichier, etc. Certaines de ces informations doivent être transmises obligatoirement, d'autres sont optionnelles ou existent par défaut. 6.1.3.1 INSTRUCTION D'OUVERTURE : OPEN L'instruction d'ouverture d'un fichier et son exécution effectuent la liaison entre le programme et l'unité logique spécifiée dans l'instruction. Elle permet également de fixer les caractéristiques d'un fichier. La syntaxe est :

open ( [unit = ] uni [,file = nomfich ]...) avec : uni expression positive de type integer indiquant le numéro attribué à l'unité logique laquelle sera connecté le fichier externe, nomfich expression de type character qui fixe le nom du fichier externe à relier avec l'unité logi-

que de l'instruction. Les clauses applicables à l'instruction open sont (description sous 6.1.2) : unit = uni access = 'sequential' | 'direct' blank = 'null' | 'zero' err = etiq file = nomfich form = 'formatted' | 'unformatted' iostat = istat recl = rlong status = 'old' | 'new' | 'scratch' | 'unknown'

- 148 -


Les règles applicables aux unités logiques définies dans l'instruction open sont les suivantes : 1. l'unité logique est globale dans le programme exécutable. Sa validité se transmet également dans

tous les sous-programmes ou du sous-programme où se trouve l'instruction dans toutes les autres unités du programme.

2. l'unité logique est connectée au programme par l'instruction open et se déconnecte par l'instruc-tion de fermeture du fichier close ou par la fin d'exécution normale du programme.

3. un fichier ne peut être relié qu'à une seule unité logique à un moment donné du déroulement du programme;

4. il est recommandé de conserver les numéros d'unités logiques 5, 6 et 7 pour les unités standards d'entrée - sortie et de limiter la numérotation à deux chiffres. Le numéro maximal dépend de l'implémentation du langage.

6.1.3.2 UTILISATION DE L'OUVERTURE Donnons quelques exemples avec commentaires : open (unit = 3, file = 'papier.dat', err = 100) Dans cette instruction, l'ouverture crée un fichier à accès séquentiel relié à l'unité logique 3 , le nom du fichier sur le disque étant papier.dat et l'étiquette de l'instruction exécutable traitant d'une erreur à l'ouverture valant 100 . open (4,file='system.duf',status='old',access='sequential', + form='unformatted') Cette instruction ouvre un fichier existant system.duf en accès séquentiel, les données étant bi-naires, et le fichier se connecte à l'unité 4. 6.1.3.3 EXEMPLE D'OUVERTURE D'UN FICHIER Le programme proposé permet de démontrer l'emploi de l'instruction open , l'introduction de données numérique et chaînes de caractères, de relire ces données et de les afficher à l'écran. * * Exemple 28 * Opération d'ouverture sur 2 fichiers à accès séquentiel * program exem28 integer ival,icont,jval character*25 cnom,prenom,znom1,znom2 character*20 fich1,fich2 * data fich1,fich2 /'DONNE1.DAT','DONNE2.TXT'/ * write (*,'(//,15x,a,//)') + 'OUVERTURE DE DIFFERENTS FICHIERS' write (*,'(5x,a,$)') 'Donnez un nombre entier : ' read *, ival write (*,'(/,5x,a,$)') 'Donnez votre nom : ' read (*,'(a)') cnom write (*,'(12x,a,$)') 'votre prénom : ' read (*,'(a)') prenom * open (1,file=fich1,iostat=icont,status='unknown', + access='sequential') write (1,'(i8)') ival

- 149 -


rewind 1 read (1,'(i8)') jval write (*,'(/,2(5x,a,i8,/))') + 'Le fichier 1 contient : ',jval, + 'L''état du contrôle des erreurs donne : ',icont * open (2,file=fich2,status='unknown',access='sequential') write (2,'(a)') cnom,prenom rewind 2 read (2,'(a)') znom1,znom2 write (*,'(/,3(5x,a,/)/)') + 'Les noms dans le fichier 2 sont : ',znom1,znom2 * close (1) close (2) * end Résultat de l'exécution du programme OUVERTURE DE DIFFERENTS FICHIERS Donnez un nombre entier : 1234567 Donnez votre nom : MAURON votre prénom : Julien

Le fichier 1 contient : 1234567 L'état du contrôle des erreurs donne : 0

Les noms dans le fichier 2 sont : MAURON Julien 6.1.3.4 FERMETURE DES FICHIERS L'instruction de fermeture d'un fichier, provoquant la déconnexion entre le programme et le fichier, a la syntaxe :

close ( [ unit = ] uni [ , . . . ] ) avec : uni numéro de l'unité logique, de type integer, connectée au fichier externe à fermer. Les clauses applicables à l'instruction close sont (description sous 6.1.2) : unit = uni iostat = istat err = etiq status = 'keep' | 'delete'

La plupart du temps, l'instruction comprend seulement le nom de l'instruction et le numéro de l'uni-té logique. La fermeture s'effectue automatiquement à la fin du programme, mais pas nécessairement lors d'une interruption due à la présence d'une erreur ou par une action de l'utilisateur (VAX-11). Dans ce dernier cas, il est nécessaire de fermer le fichier resté ouvert par une commande propre au sys-tème d'exploitation, habituellement unlock . Dans le cas d'un fichier resté ouvert, l'ordre open ne pourrait plus s'effectuer lors du prochain appel du programme, car le fichier ne serait plus accessible !

- 150 -


6.1.4 ÉCRITURE , LECTURE ET CONTRÔLE DES FICHIERS Dans les chapitres précédents, nous avons décrit les instructions d'écriture et de lecture appli-cables aux données d'entrée - sortie sur le terminal. Ce sous chapitre présente toutes les possibilités de ces deux instructions, complétées par l'instruction de contrôle inquire . 6.1.4.1 ÉCRITURE DE DONNÉES DANS UN FICHIER L'instruction générale d'écriture de données dans les fichiers à accès séquentiel ou direct est write , accompagnée d'une ou de plusieurs clauses. La syntaxe est :

write ( [ unit = ] uni [ , . . . ] ) iolist avec : uni expression positive de type integer indiquant le numéro attribué à l'unité externe à laquelle

est connecté le fichier ou l'identificateur de fichier interne. L'unité par défaut, l'écran, peut se donner par l'astérisque. Le mot-clé unit peut être omis; dans ce cas, uni doit être la première clause de la liste.

Iolist données à transférer, soit : - des identificateurs de variables, - des tableaux ou des éléments de tableaux, - des sous-chaînes de caractères, - des listes do ... implicites, - des expressions, y compris des constantes. Les clauses applicables à l'instruction write sont (description sous 6.1.2) : err = etiq fmt = dfmt iostat = istat rec = recnum

L'instruction write transfère des données de la représentation interne vers le fichier de sortie, conformément aux paramètres de mise en forme et à la liste de sortie. FORTRAN essaie d'écrire toutes les données de la liste et lorsque la barre oblique est rencontrée, il écrit un nouvel enregis-trement, utilisant le descripteur d'édition situé à droite de la barre / . L'exploration de la mise en forme s'effectue comme décrit précédemment. 6.1.4.2 LECTURE DE DONNÉES DANS UN FICHIER L'instruction générale de lecture de données dans les fichiers à accès séquentiel ou direct est read , accompagnée d'une ou de plusieurs clauses. La syntaxe est :

read ( [ unit = ] uni [ , . . . ] ) iolist avec : uni expression positive de type integer indiquant le numéro attribué à l'unité externe à laquelle le

fichier est connecté ou l'identificateur du fichier interne. Le mot-clé unit peut être omis; dans ce cas, uni doit être la première clause. Le clavier peut s'identifier par * .

iolist données à transférer, soit : - des identificateurs de variables, - des tableaux et des éléments de tableaux, - des sous-chaînes de caractères, - des listes do ... implicites. Les clauses applicables à l'instruction read sont (description sous 6.1.2) : end = etiq err = etiq

- 151 -


fmt = dfmt iostat = istat rec = recnum

L'instruction read transfère des données d'un fichier vers une représentation interne, conformé-ment à la mise en forme ou le type de données. FORTRAN lit tous les éléments de la liste conformé-ment aux règles de rangement, en particulier celui des tableaux. Si le compilateur rencontre une barre oblique dans les spécifications de mise en forme, il utilise les descripteurs se situant à droite de la barre / . 6.1.4.3 INSTRUCTION INQUIRE L'instruction inquire est une instruction de contrôle permettant de donner des renseignements sur l'état des fichiers et de diriger le déroulement du programme en conséquence en cas d'anomalies. La syntaxe est :

inquire ( [ unit = ] uni | file = nomfich [ , ... ] ) avec : uni expression positive de type integer indiquant le numéro attribué à l'unité externe à

laquelle le fichier est connecté , valable pour un contrôle par identification du numéro d'unité.

nomfich nom du fichier à contrôler par l'instruction inquire . Les nombreuses clauses applicables à l'instruction inquire sont (description sous 6.1.2) : access = mode blank = blanc direct = dir err = etiq exist = lexis form = fcode formatted = fmtd iostat = istat name = nom named = lnom nextrec = next opened = lopen recl = rlong sequential = seq unformatted = unf

L'instruction inquire permet de déterminer l'existence d'une unité ou d'un fichier particulier et de retrouver les caractéristiques de ce fichier ou unité. L'affectation des nombreuses variables et leur trai-tement augmentent la fiabilité du programme. Il existe deux variantes de cette instruction : l'identi-fication par le numéro de l'unité ou par le nom du fichier. Les autres clauses de l'instruction sont applicables dans les deux cas. La clause opened , qui vaut .true. si le fichier ou l'unité est ouvert et .false. si ce n'est pas le cas est recommandée en premier lieu. Le contrôle par inquire et le nom du fichier est employé lorsque ce fichier a été ouvert et fermé de nombreuses fois dans le déroulement du programme. L'instruction permet de retrouver sa fonction et d'agir en conséquence. Le contrôle par inquire et le numéro de l'unité est introduit lorsque le même numéro a été attri-bué à de nombreux fichiers externes. L'instruction permet de retrouver le nom du fichier connecté, de savoir si ce dernier est ouvert ou fermé, son mode d'accès et son codage, etc.

- 152 -


6.1.5 INSTRUCTIONS COMPLÉMENTAIRES Il existe encore quelques instructions complémentaires sur la manipulation des fichiers, à part la lecture, l'écriture et le contrôle des états. 6.1.5.1 RÉINITIALISATION D'UN FICHIER Si le programme doit relire un fichier à accès séquentiel à partir de son début, sans procéder à la fermeture du fichier, il est possible de donner l'instruction sous deux formes :

rewind [unit =] uni rewind ( [unit =] uni [ , . . . ] ) avec : uni numéro de l'unité logique connectée au fichier. Le mot-clé unit est optionnel si c'est le pre-

mier argument de la liste. Les deux autres clauses de la liste entre parenthèses sont option-nelles.

Les clauses supplémentaires applicables à l'instruction rewind sont (description voir 6.1.2) : iostat = istat err = etiq

Le numéro de l'unité logique spécifié dans l'instruction rewind se réfère à un fichier à accès sé-quentiel placé sur disque. Le pointeur de fichier va se placer au point de départ du fichier, soit avant le premier enregistrement. 6.1.5.2 MARQUE DE FIN DE FICHIER L'instruction endfile permet de mettre en place une fin de fichier après le dernier enregistrement traité en lecture ou en écriture dans un fichier ouvert en accès séquentiel. La syntaxe de l'instruction peut prendre deux formes :

endfile uni endfile ( unit = uni [ , . . . ] ) avec : uni numéro de l'unité logique connectée au fichier externe. La clause unit = est optionnelle si

uni est le premier argument de la liste et ne doit pas apparaître dans la première forme de l'instruction.

Les clauses supplémentaires applicables à l'instruction endfile sont (description voir 6.1.2) : iostat = istat err = etiq

Cette instruction n'est applicable qu'aux fichiers séquentiels. Elle permet de réinitialiser un fichier ouvert sûrement si ce fichier n'a pas été fermé et d'assurer qu'aucun enregistrement ne subsiste dans le fichier. On peut également terminer l'écriture d'un fichier séquentiel plus court par cette instruction. Exemple : endfile (10,iostat=istat,err=250)

Cette instruction met une marque de fin de fichier à la position actuelle du pointeur et si une erreur intervient, le programme continue à l'instruction exécutable étiquetée 250 , la variable entière istat contenant le numéro de l'erreur ou zéro si l'opération s'est déroulée correctement.

- 153 -


6.1.5.3 RECUL D'UN ENREGISTREMENT L'instruction backspace permet de relire ou de récrire un enregistrement. La syntaxe peut pren-dre deux formes :

backspace uni backspace ( unit = uni [ , . . . ] ) avec : uni numéro de l'unité dans laquelle il faut effectuer un recul d'un enregistrement. La clause unit =

peut être omise si c'est le premier argument de la liste entre parenthèses. Les clauses supplémentaires applicables à l'instruction backspace sont (description voir 6.1.2) : iostat = istat err = etiq

L'instruction déplace le pointeur dans le fichier connecté juste avant celui qui a été lu ou écrit. Il est aussi possible d'employer backspace pour positionner le pointeur juste avant la marque de fin de fichier, afin d'enregistrer des données supplémentaires. Si le pointeur de fichier se trouve au début du fichier, l'instruction n'a pas d'effet. Le fichier doit être bien entendu ouvert avant de donner cette instruction. Le numéro de l'unité lo-gique doit être spécifié et ne peut pas être l'astérisque * . Exemples : backspace 8 backspace (unit=9,iostat=istret,err=1000)

La première instruction déplace le pointeur de -1 enregistrement dans le fichier connecté par l'unité 8 , la seconde instruction dans le fichier connecté par l'unité 9 , avec affectation du numéro d'erreur à la variable istret et saut à l'instruction étiquetée 1000 en cas d'erreur d'exécution.

6.2 FICHIERS À ACCÈS SÉQUENTIEL L'accès séquentiel aux données d'un fichier permet de lire ou d'écrire ce fichier du début à la fin, enregistrement après enregistrement, sans pouvoir sélectionner dans le fichier un enregistrement par-ticulier à partir d'un numéro d'ordre. Ce sous-chapitre comprend deux parties : la structure des instruc-tions adaptées à ce genre de fichiers et les algorithmes de programmation pour atteindre certaines fonctionnalités. 6.2.1 OPÉRATIONS SUR LES FICHIERS SÉQUENTIELS Comme toute manipulation de fichier nécessite tout d'abord son ouverture, l'écriture et/ou la lec-ture de données et finalement la fermeture du fichier, nous voulons citer les cas les plus fréquents et les instructions nécessaires dans les cas fondamentaux. 6.2.1.1 OUVERTURE DU FICHIER SÉQUENTIEL L'ouverture du fichier se réalise par l'instruction open accompagnée au moins de l'unité logique, du nom du fichier, du mode d'accès et de la nature du codage si nécessaire, les options par défaut étant applicables. Elle peut se compléter par les clauses de traitement des erreurs. En introduisant fich1.dat pour un fichier codé et fich2.duf pour un fichier binaire, les instructions usuelles d'ouverture deviennent : 1. Fichier codé :

- 154 -


open (1,file='fich1.dat',status='unknown',access='sequential', + form='formatted')

2. Fichier binaire : open (2,file='fich2.duf',status='unknown',access='sequential', + form='unformatted')

Des clauses complémentaires peuvent se donner dans cette instruction, voir la description com-plète de l'instruction d’ouverture. Il est recommandé de programmer les clauses par défaut afin de reconnaître immédiatement la nature du fichier. 6.2.1.2 ÉCRITURE D'UN FICHIER SÉQUENTIEL Le transfert vers le fichier se réalise par une instruction write accompagnée de l'identification de l'unité logique, de la mise en forme si la forme codée est utilisée, des clauses de traitement des er-reurs si nécessaire, de la liste des données à écrire dans le fichier. La transmission des données sous forme binaire ne nécessite pas de mise en forme. Les variables utilisées dans les exemples sont déclarées comme suit : integer i,k real*4 a,b,c,e,f,r,s character chain1*12,chain2*16,chain3*32,chain4*8

1. Ecriture de données numériques codées (sans les clauses de traitement des erreurs) : write (1,'(2f10.4,e12.5,2i8)') a,b,c,i,k

- écriture de données chaînes de caractères codées : write (1,'(3a)') chain1,chain2,chain3

- écriture de données numériques et alphanumériques codées : write (1,'(2g12.5,a,2F10.3)') e,f,chain4,r,s

2. Ecriture de données numériques binaires (sans les clauses de traitement des erreurs) : write (2) a,b,c,i,k

- écriture de données chaînes de caractères binaires : write (2) chain1,chain2,chain3

- écriture de données numériques et alphanumériques binaires : write (2) e,f,chain4,r,s

Particularités de l'écriture des données de type character : Le nombre d'octets transmis par les données chaînes de caractères est égal à la dimension dé-clarée, si la mise en forme ne contredit pas cette règle d'occupation en mémoire. L'écriture des données codées dans le fichier se déroule comme suit : 1. lecture des données soit à partir d'une frappe au clavier ou d'une opération dans le programme

avec affectation aux variables citées; 2. traduction de ces données binaires en suites de caractères; 3. écriture de cette forme alphanumérique dans le fichier externe en mode séquentiel. Si les données sont binaires, la traduction en suites de caractères n'est pas nécessaire, ni à l'écri-ture, ni à la lecture, d'où gain de temps et de places mémoire.

- 155 -


6.2.1.3 LECTURE D'UN FICHIER SÉQUENTIEL L'instruction générale de lecture est read accompagnée du numéro de l'unité logique, des clauses complémentaires et de la liste des variables à affecter. Les variables utilisées dans les exemples sont déclarées comme suit (comme en écriture) : integer i,k real*4 a,b,c,e,f,r,s character chain1*12,chain2*16,chain3*32,chain4*8 1. Lecture de données numériques codées (sans les clauses de traitement des erreurs) : read (1,'(2f10.4,e12.5,2i8)') a,b,c,i,k - lecture de données chaînes de caractères codées : read (1,'(3a)') chain1,chain2,chain3 - lecture de données numériques et alphanumériques codées : read (1,'(2g12.5,a,2F10.3)') e,f,chain4,r,s 2. Lecture de données numériques binaires (sans les clauses de traitement des erreurs) : read (2) a,b,c,i,k - lecture de données chaînes de caractères binaires : read (2) chain1,chain2,chain3 - lecture de données numériques et alphanumériques binaires : read (2) e,f,chain4,r,s Les particularités de l'écriture des données de type character sont aussi applicables à la lecture de ces données. Pour que la lecture codée s'effectue correctement, ces données étant stockées dans le fichier sous forme de suites de caractères, donc non sous forme numérique, il faut que la mise en forme de l'instruction de lecture soit absolument identique à celle employée lors de l'écriture. La lecture binaire ne nécessite pas ces transformations, le nombre d'octets transférés étant imposé par le type des variables à affecter. 6.2.1.4 CONTRÔLE DE LA TRANSMISSION DES DONNÉES Le contrôle de la transmission des données peut s'effectuer de diverses manières : ajout de clauses de traitement des erreurs et/ou introduction de l'instruction inquire avec ses nombreuses clauses. Cette dernière possibilité permet de récupérer les diverses caractéristiques du fichier sous forme d'états logiques, de valeurs numériques et de chaînes de caractères. 6.2.1.5 EXEMPLE D'UN FICHIER SÉQUENTIEL L'exemple proposé consiste à créer un tableau de valeurs numériques composées d'un calcul au moyen des fonction sinus, cosinus et tangente d'un argument variant entre x = 0.00 et x = n*0.01 , le nombre d'incréments étant choisi par l'utilisateur, le pas valant 0.01. Les valeurs numériques du tableau sont stockées dans un fichier sous forme binaire et sont lues de ce fichier et écrites après transformation binaire – texte en clair.

- 156 -


* * Exemple 29 * Essai d'un fichier à accès séquentiel avec génération d'un * tableau de fonctions trigonométriques * program exem29 integer i,ioch,n,nunit logical lexis,lnom,lopen real*4 c,s,t,x character rep*1,fiche*12,fich1*12 intrinsic cos,mod,sin,tan * write (*,'(//,20x,a,//,16x,a,//,5x,a,$)') + 'CREATION D''UN FICHIER A ACCES SEQUENTIEL', + 'Génération d''un tableau de fonctions trigonométriques', + 'Donnez le nom du fichier (8 caractères) : ' read (*,'(a)') fich1 fich1(9:12) = '.DUF' write (*,'(/,5x,a,$)') + 'Donnez le nombre de valeurs à calculer : ' read *, n * open (8,file=fich1,status='unknown',access='sequential', + form='unformatted') do i=0,n x=0.01*i s=sin(x) c=cos(x) t=tan(x) write (8) i,x,s,c,t end do close (8) write (*,'(//,10x,a,//,5x,a,$)') + 'FIN DE LA CREATION DU FICHIER', + 'Pressez sur <RET> ' read (*,'(a1)') rep * write (*,'(//,10x,a,/)') 'Lecture du fichier' open (9,file=fich1,status='old',access='sequential', + form='unformatted') 20 read (9,end=100) i,x,s,c,t write (*,'(1x,i10,f10.4,2f12.7,f16.7)') i,x,s,c,t if (mod(i,5) .eq. 0) write (*,*) go to 20 * 100 continue inquire (unit=9,exist=lexis,named=lnom,iostat=ioch, + opened=lopen,number=nunit,name=fiche) write (*,'(//,10x,a,//,2(5x,a,i5,/),3(5x,a,l5,/),5x,a,a,/)') + 'ETAT DU FICHIER LU AVANT CLOTURE', + 'Numéro de l''unité raccordée : ',nunit, + 'Etat des entrées/sorties : ',ioch, + 'Le fichier existe : T = oui : ',lexis, + 'Le fichier possède un nom : T = oui : ',lnom, + 'Le fichier est ouvert : T = oui : ',lopen, + 'Le nom du fichier est : ',fiche

- 157 -


* close (9) end Résultat de l'exécution du programme

CREATION D'UN FICHIER A ACCES SEQUENTIEL

Génération d'un tableau de fonctions trigonométriques Donnez le nom du fichier (8 caractères) : FICHIER1 Donnez le nombre de valeurs à calculer : 200

FIN DE LA CREATION DU FICHIER

Pressez sur <RET>

0 0.0000 0.0000000 1.0000000 0.0000000 1 0.0100 0.0099998 0.9999500 0.0100003 ........................................................ 200 2.0000 0.9092975 -0.4161468 -2.1850400

ETAT DU FICHIER LU AVANT CLOTURE

Numéro de l'unité raccordée : 9 Etat des entrées/sorties : 0 Le fichier existe : T = oui : T Le fichier possède un nom : T = oui : T Le fichier est ouvert : T = oui : T Le nom du fichier est : FICHIER1.DUF 6.2.2 ALGORITHMES DE TRAITEMENT De nombreux algorithmes sont à disposition pour traiter les données d'un fichier séquentiel, ces fichiers pouvant subir le plus souvent des modifications pendant leur durée de vie. Nous voulons traiter ici les principales opérations dans la pratique courante. 6.2.2.1 CLASSEMENT DES FICHIERS Ce classement est applicable aux fichiers à accès séquentiel et direct. La durée de vie peut servir comme critère de choix. Les fichiers sont classés en : 1. Fichiers permanents Ces fichiers contiennent des données pratiquement invariables pendant toute leur durée de vie. Ce sont des fichiers d'archives de données de l'état d'une utilisation, comme par exemple des comptes financiers, des résultats d'observation ou des tables de constantes et propriétés physiques. 2. Fichiers dynamiques Ces fichiers contiennent des données modifiables comme un état de stock de pièces, d'adresses d'un groupe de personnes, etc. 3. Fichiers temporaires Ce genre de fichier s'utilise pendant l'exécution du programme et sert à conserver provisoirement des informations qui seront transférées par la suite dans un fichier soit dynamique, soit permanent sous forme d'ajouts.

- 158 -


6.2.2.2 LONGUEUR DES ENREGISTREMENTS Deux cas peuvent se présenter : 1. la longueur de tous les enregistrements, c'est-à-dire la configuration des données, est constante

dans tout le fichier. Ce cas est relativement rare dans la programmation courante. Le traitement est fortement simplifié puisque la liste reste invariable.

2. la longueur des enregistrements varie, c'est-à-dire que quelques ou tous les enregistrements pos-sèdent des affectations différentes. C'est le cas général.

La difficulté est de pouvoir relire correctement les données placées dans chaque enregistrement en affectant correctement les données du fichier aux variables de la liste de l'instruction read (...) . Le programme devrait "se souvenir" de la configuration de chaque enregistrement. La méthode générale consiste à prévoir un enregistrement se composant de deux parties : - la première fixe avec un identificateur de la partie mobile, - la seconde variable en fonction des données à enregistrer. La boucle do ... implicite permet de résoudre ce genre de problème. La forme générale de l'ins-truction clé de cette structure serait pour la lecture des enregistrements : read (iuni) partie fixe lisant nombre,(partie mobile,j=1,nombre) Afin de montrer le principe de la programmation d'une structure de ce genre, créons dans l'exem-ple 30 un fichier à enregistrements variables. Les enregistrements du fichier se composent : 1. d'une partie fixe constituée par les données affectées aux variables : i numéro de l'enregistrement, n'est pas absolument nécessaire dans ce cas, n le nombre de valeurs créées pseudo-aléatoirement. 2. d'une partie variable, la valeur de n étant générée également pseudo-aléatoirement entre 1 et 10.

La partie variable comprend n valeurs réelles comprises entre -100.00 et +100.00 . Après stockage de toutes les données dans le fichier, le pointeur est positionné au début du fi-chier et les valeurs se trouvant dans chaque enregistrement sont affichées à l'écran. * * Exemple 30 * Création d'un fichier à accès séquentiel * Enregistrements à dimension aléatoirement variable * program exem30 integer i,j,n,nomb real*4 aini,alea,valeur,val(10) character fiche*12,rep*1 intrinsic abs,int,mod external alea * write (*,'(//,20x,a,//,5x,a,$)') + 'GENERATION D''ENREGISTREMENTS A TAILLE VARIABLE', + 'Donnez le nom complet du fichier (max. 12 caractères) : ' read (*,'(a)') fiche write (*,'(12x,a,$)') 'un nombre réel avec 5 décimales : ' read *, valeur aini=abs(valeur) write (*,'(12x,a,$)') 'le nombre d''enregistrements désiré : ' read *, nomb * open (4,file=fiche,status='unknown',access='sequential', + form='unformatted') * * Ecriture des parties fixe et mobiles dans le fichier *

- 159 -


do i=1,nomb aini=alea(aini) n=1+int(10.0*aini) do j=1,n aini=alea(aini) val(j)=200.0*(aini-0.5) end do write (4) i,n,(val(j),j=1,n) end do * write (*,'(///,10x,a,//,5x,a,\)') + 'FIN DE LA CREATION DU FICHIER', + 'Pressez sur la touche <RET> ' read (*,'(a1)') rep * * Lecture du fichier après positionnement du pointeur * rewind 4 write (*,'(//,10x,a,//)') 'LECTURE DU FICHIER' 30 read (4,end=100) i,n,(val(j),j=1,n) write (*,'(10x,a,i4,5x,a,i3,/,(5x,5f13.5))') + 'Enregistrement : ',i,'Nombre : ',n,(val(j),j=1,n) if (mod(i,5) .eq. 0) print * goto 30 * 100 continue write (*,'(//,10x,a,//)') 'FIN DE PROGRAMME' close(4) end * * Générateur de valeurs pseudo-aléatoires * real function alea (a) real*4 a,b intrinsic int b=29.0*a alea=b-int(b) end Résultat de l'exécution du programme GENERATION D'ENREGISTREMENTS A TAILLE VARIABLE Donnez le nom complet du fichier (max. 12 caractères) : FICHIER.DUF un nombre réel avec 5 décimales : 3.45678 le nombre d'enregistrements désiré : 50 FIN DE LA CREATION DU FICHIER Pressez sur la touche <RET> LECTURE DU FICHIER Enregistrement : 1 Nombre : 3 -69.61127 -18.72663 56.92759 ...................................... etc.

FIN DE PROGRAMME

- 160 -


6.2.2.3 LECTURE D'UN ENREGISTREMENT À CHOIX La lecture d'un fichier à accès séquentiel s'effectue du début à la fin du fichier, les enregistrements n'étant pas numérotés. Si le fichier est très volumineux et que l'on désire traiter un enregistrement bien déterminé, il est possible d'atteindre ces données sans devoir lire les données les précédant. La méthode utilisée consiste à déplacer le pointeur d'enregistrement, à partir du début du fichier atteint par open ou rewind , au moyen d'une instruction de lecture sans liste dont la forme générale serait : read (iuni,clause) dans laquelle : iuni est le numéro de l'unité logique connectée au fichier, clause est l'ensemble des clauses et les descripteurs de format si le fichier est codé. Si le fichier est codé, la clause de mise en forme peut être '(1x)' Les clauses utilisables sont : err = ... ou iostat = ... . 6.2.2.4 EXTENSION D'UN FICHIER EXISTANT L'extension d'un fichier est une opération assez fréquente. Elle consiste à ajouter, en fin de fichier, de nouveaux enregistrements. Les compilateurs comprenant le mode d'accès hors norme 'append' permettent de résoudre élégamment ce problème. Il suffit de donner, dans l'instruction d'ouverture du fichier, la clause : access = 'append' pour positionner le pointeur en fin de fichier. C'est un cas particulier du mode d'accès séquentiel. MS-FORTRAN possède une fonction logique très utile end of file , mais hors norme, eof(iuni ) qui prend la valeur .true. seulement lorsque le pointeur se trouve en fin de fichier, sinon elle retourne la valeur .false. . Le paramètre iuni est le numéro de l'unité logique. Une autre possibilité élémentaire d'étendre un fichier est : 1. ouvrir le fichier à étendre et un nouveau fichier de même caractéristiques que le fichier existant, 2. copier le fichier à modifier dans le nouveau fichier, 3. procéder aux ajouts désirés en fin du nouveau fichier, 4. fermer l'ancien et le nouveau fichier, 5. effacer l'ancien fichier et le remplacer par le nouveau en lui donnant le même nom. 6.2.2.5 TABLEAUX CONDENSÉS Il arrive assez fréquemment, surtout en technique, de devoir traiter des tableaux carrés présentant une structure à bande, c'est-à-dire que la plupart des éléments sont placés près de la diagonale prin-cipale, tous les autres éléments étant nuls. Les tableaux peuvent posséder des dimensions allant de quelques centaines de lignes ou de colonnes à plusieurs milliers, soit un nombre d'éléments s'éten-dant de 104 à 106 et plus. Il ne serait pas sage de conserver tous les éléments du tableau dans un fi-chier, mais seulement la partie située près de la diagonale principale. L'enregistrement des éléments devrait comprendre le numéro de ligne, le numéro de colonne du premier élément non nul de la ligne et le numéro de colonne du dernier élément non nul de la ligne. C'est un cas particulier des enregis-trements à taille variable. L'instruction de lecture aurait la forme générale : read (10) nli,nc1,nc2,(a(nli,j),j=nc1,nc2) dans laquelle nli est le numéro de ligne, nc1 et nc2 les numéros de colonne du premier et du der-nier élément non nul, a (nli,j ) étant les éléments à lire entre les deux éléments extérieurs non nuls.

- 161 -


6.2.3 LES FICHIERS DE TEXTE Un fichier de texte ou fichier de caractères se compose d'un ensemble de lignes constituées par des suites de caractères, terminées par un terminateur de ligne et la dernière ligne par une fin de fi-chier. Contrairement au langage Pascal, FORTRAN ne reconnaît pas le caractère seul comme enre-gistrement, mais seulement la ligne. Habituellement, la longueur des lignes est variable. 6.2.3.1 ÉCRITURE ET LECTURE D'UN FICHIER TEXTE L'écriture d'un fichier texte peut se réaliser de deux manières : 1. Ecriture du fichier au moyen d'un éditeur permettant par exemple de composer un texte, un pro-

gramme source, des informations ou des tableaux de valeurs numériques. 2. Ecriture du fichier au moyen d'un programme en introduisant l'instruction write (...) et une mise en

forme codée des données. Ces deux genres de fichiers peuvent être modifiés soit au moyen d'un éditeur, soit dans un pro-gramme. La lecture d'un fichier texte intervient dans les conditions suivantes : 1. lecture du fichier à l'extérieur du programme pour contrôle de son contenu ou pour information à

l'utilisateur. 2. lecture du fichier texte dans le programme, ligne après ligne avec affichage à l'écran du contenu.

Un exemple typique est le fichiers contenant toutes les informations sur le programme ou des ta-bleaux de caractéristiques.

3. lecture du fichier texte dans le programme, sans affichage à l'écran, mais avec traitement des va-leurs lues. Le contenu de chaque ligne est affecté à une variable chaîne de caractères, puis dé-composé en parties grâce à l'emploi de sous-chaînes. Chaque sous-chaîne représente une seule entité qui peut de transformer par exemple en valeur numérique.

6.2.3.2 EXEMPLE DE LECTURE L'exemple proposé, programmé pour un micro-ordinateur en MS-FORTRAN, permet de lire un fichier d'informations et de l'afficher à l'écran en interrompant l'écriture des lignes à 22 lignes. Cet exemple comprend le sous-programme permettant d’effacer l’écran utilisé souvent par la suite. * * Exemple 31 * Lecture d'un fichier texte à raison de 22 lignes par écran * program exem31 * call efface call ecran call inform call efface end * * Effaçage de l'écran * subroutine efface write (*,'(1x,a1,a2,a1,a3)') char(27),'[H',char(27),'[2J' end * * Sous-programme de lecture des informations * Le nombre de caractères est de 80 par ligne *

- 162 -


subroutine inform integer k character fiche*32,texte*80 * write (*,'(//,10x,a,\)') + 'Donnez le nom externe du fichier : ' read (*,'(a)') fiche open (8,file=fiche,status='old') * k=0 call efface 10 read (8,'(a80)',end=15) texte write (*,'(1x,a80)') texte k=k+1 if (k .eq. 22) then call touche k=0 call efface end if goto 10 15 continue * write (*,'(///)') close (8) call touche end * * Sous-programme d'initialisation de l'écran * subroutine ecran * call efface write (*,'(///,20x,a,///)') + 'LECTURE D''UN FICHIER D''INFORMATIONS', call touche end * * Sous-programme d'arrêt et de pression sur la touche <RET> * subroutine touche character*1 rep write (*,'(/,10x,a,\)') c 'Pour continuer, pressez sur la touche <RET> ' read (*,'(a1)') rep end Ce programme se compose d'un programme principal et des sous-programmes : - efface effacement de l'écran; - inform introduction du nom du fichier à lire, ouverture du fichier, lecture à raison de 22 lignes par

écran, fermeture du fichier; - ecran affichage du titre (menu minimal); - touche arrêt du programme et continuation par pression sur la touche <RET>. Ce programme utilise la gestion de l'écran au moyen de séquences escape , conformément aux normes ANSI . Le sous-programme inform réserve 80 caractères par ligne. L'affichage d'une ligne complète peut présenter une petite difficulté si la gestion d'écran met le pointeur à la ligne lorsque la

- 163 -


colonne 80 est atteinte. Dans ce cas, il faut prévoir 79 caractères par ligne et ne pas dépasser cette valeur dans le fichier texte.

Le nombre de lignes affichées est 22 , le compteur k incrémentant de 1 après l'écriture de la ligne à l'écran. Si k = 22 , alors l'écran affiche : Pour continuer, pressez sur la touche <RET> et l'écran s'efface; l'affichage continue jusqu'à ce que la dernière ligne du fichier soit atteinte. 6.2.3.3 ACCÈS AUX PÉRIPHÉRIQUES La liaison entre le programme et le terminal s'effectue par l'intermédiaire des unités logiques pré-connectées : unités logiques 5 ou * en lecture, unités logiques 6 ou * en écriture. Par contre, la liaison entre le programme et une imprimante externe ou un traceur de courbes doit se programmer par l'ouverture d'un fichier. Cette méthode de programmation est avantageuse pour les postes de travail mono-utilisateur. Par contre, dans les systèmes multi utilisateurs, il est recommandé de transférer les données dans des fichiers et d'accéder aux périphériques par l'intermédiaire de fichiers et des com-mandes du système d'exploitation. Le nom du fichier permettant d'accéder au périphérique dépend du système d'exploitation et du chemin à parcourir pour atteindre cette unité. Le transfert vers une imprimante personnelle, program-mée en MS-FORTRAN, pourrait se déclarer par :

open (3,file='prn:') write (3,'(...)') liste de variables Ici, l'unité logique connectée à l'imprimante porte l'identificateur 3 .

6.2.4 FICHIERS INTERNES Un fichier interne est représenté par une variable ou un élément de tableau de type character servant de source ou de destination à des opérations d'entrée - sortie. 6.2.4.1 TRANSFERT DE DONNÉES Le transfert de données s'effectue dans les deux sens : du fichier interne vers la liste des varia-bles à affecter ou de la liste des entités vers le fichier interne. Le fichier interne contient exactement un enregistrement dont la longueur est égale à celle de la variable ou de l'élément de tableau de type character. Si les entités transférées sont plus courtes que la place prévue, la partie restante de l'enregistre-ment est remplie de blancs. Les données doivent être obligatoirement codées. Le pointeur de fichier se trouve toujours au début du fichier. Les seules instructions autorisées sont : 1. Lecture dans le fichier interne : read (fichint,'(codage)',clauses) liste des variables à affecter 2. Ecriture dans le fichier interne : write (fichint,'(codage)',clauses) liste des expressions

Les clauses optionnelles applicables sont : iostat=... et err=... . Les fichiers internes possèdent une possibilité de mise en forme des données afin de convertir les données vers ou depuis leur représentation externe sous forme de caractères en représentation in-terne dans la mémoire. En lisant une valeur du fichier interne, cette valeur est transformée en valeur numérique, logique ou chaîne de caractères et vice versa en écriture.

- 164 -


6.2.4.2 EXEMPLE DE TRANSFORMATION L'exemple proposé permet d'introduire la virgule et le zéro devant la virgule dans l'écriture d'une somme d'argent.

* * Exemple 32 * Transformation de sommes d'argent en valeurs européennes * avec écriture de la virgule et des zéros non significatifs * program exem32 real*4 somme character transf*12,rep*1 logical lrep * data lrep /.true./ * write (*,'(//,15x,a,//)') + 'ECRITURE D''UNE SOMME EN FRANCS AVEC LA VIRGULE' * do while (lrep) write (*,'(/,5x,a,$)') + 'Donnez une somme en Frs avec point décimal : ' read *, somme write (transf,'(f12.2)') somme transf(10:10)=',' if ((somme .lt. 1.0) .and. (somme .ge. 0.0)) transf(9:9)='0' write (*,'(5x,a,f12.2,2a,//,5x,a,$)') + 'La somme ',somme,' est transformée en : ',transf, + 'Désirez-vous une autre valeur (o/n) ? ' read (*,'(a1)') rep lrep=(rep .eq. 'o') .or. (rep .eq. 'O') end do * end Cet exemple montre la possibilité de transformer une valeur numérique en chaîne de caractères au moyen du fichier interne d'identificateur transf . Le fichier prend la place de l'unité logique dans l'écriture de l'instruction. Résultat de l'exécution du programme ECRITURE D'UNE SOMME EN FRANCS AVEC LA VIRGULE Donnez une somme en Frs avec point décimal : 123.45 La somme 123.45 est transformée en : 123,45 Désirez-vous une autre valeur (o/n) ? o

Donnez une somme en Frs avec point décimal : 0 La somme 0.00 est transformée en : 0,00 Désirez-vous une autre valeur (o/n) ? n La transformation inverse, d'une chaîne de caractères en valeur numérique, est programmable par l'instruction read (...) . Cette méthode de programmation s'emploie dans la transformation d'un fichier de valeurs représentant des nombres, codé ASCII, en valeurs numériques. Le langage FORTRAN n'utilise donc pas une fonction particulière dans ce but comme par exemple val(...) en Pascal ou Basic.

- 165 -


6.3 FICHIERS À ACCÈS DIRECT Les fichiers à accès direct, en anglais informatique random-access files, permettent de sélection-ner les enregistrements ordonnés et numérotés dans le fichier. Les enregistrements correspondent approximativement aux éléments d'un vecteur, chaque ligne pouvant contenir des données de type différent, mais de longueur maximale fixée lors de l'ouverture du fichier. 6.3.1 OPÉRATIONS SUR LES FICHIERS À ACCÈS DIRECT Les fichiers à accès direct nécessitent tout d'abord l'appel du fichier à traiter par l'opération d'ou-verture, la lecture et/ou l'écriture de données, finalement la fermeture du fichier après son utilisation. Ce sous-chapitre présente l'application des instructions de base aux fichiers à accès direct. 6.3.1.1 OUVERTURE DU FICHIER À ACCÈS DIRECT L'ouverture du fichier à accès direct se commande par l'instruction open accompagnée au moins de l'unité logique, du nom du fichier, du mode d'accès, de la nature du codage, de la longueur totale des enregistrements et des options complémentaires comme le traitement des erreurs. Dans ce sous-chapitre, nous admettrons que les fichiers utilisés sont désignés par : 1. accès direct : données codées ------> fich1.dat 2. accès direct : données binaires ------> fich2.duf Les variables à affecter ou à écrire sont déclarées comme suit :

integer*4 i,k real*4 a,b,c,e,f,r,s character chain1*12,chain2*16,chain3*32,chain4*8

Il est vivement recommandé d'utiliser des enregistrements binaires plutôt que codés, car les trans-ferts sont plus rapides, sans perte de précision car aucune transformation n'est nécessaire à la lecture ou à l'écriture. La longueur des enregistrements reste une constante pour le fichier. Cette dimension doit se don-ner lors de l'ouverture du fichier. Si tous les enregistrements ont même longueur, la longueur à décla-rer est celle d'un enregistrement tandis que si les enregistrements sont à longueur variable, c'est la longueur maximale qui doit figurer dans la clause recl = ... . La longueur est calculée soit en octets pour les fichiers codés, soit en longs mots pour les fichiers binaires, cette méthode de calcul dépen-dant de l'implémentation du langage. Pour les trois versions discutées ici, la longueur se détermine comme suit : 1. DOMAIN FORTRAN :

La longueur s'exprime en octets pour les fichiers à accès direct ou séquentiel, que les données soient binaires ou codées. Le paramètre rlong doit être une expression entière. Pour les nou-veaux fichiers à accès direct, la longueur est égale à la longueur prévue + 1 octet. Pour un fichier existant à accès direct, rlong peut être toute dimension inférieure ou égale à la longueur actuelle. Si la clause est absente à l'ouverture d'un fichier existant, FORTRAN admet la longueur du plus grand enregistrement. Si la clause est omise à la création d'un nouveau fichier, la longueur par défaut sera 256 octets.

2. MS-FORTRAN :

La longueur de chaque enregistrement s'exprime en octets, l'argument rlong doit se donner pour les fichiers à accès direct, mais est ignorée pour les fichiers à accès séquentiel.

- 166 -


3. VAX-11 FORTRAN : La longueur de l'enregistrement se donne en octets pour les fichiers codés, maximum 32766 octets, en longs mots de 4 octets, maximum 8191 mots sur disque. Les règles applicables sont : - si la clause est absente lors de l'ouverture d'un fichier existant, la longueur spécifiée lors de la création du fichier est valable. - si le programme doit écrire un enregistrement plus grand que la valeur spécifiée, une erreur est signalée. - si le fichier contient des enregistrements à longueur fixe et et que la clause recl spécifie une di-mension différente, une erreur est signalée.

Chaque implémentation présente donc ses propres caractéristiques qui rendent les programmes difficilement portables d'une implémentation à l'autre. Les instructions générales sont données ci-après. 1. fichier codé : open (1,file='fich1.dat',status='unknown',access='direct', + form='formatted',recl=lf1) 2. fichier binaire : open (2,file='fich2.duf',status='unknown',access='direct', + form='unformatted',recl=lf2)

Dans ces deux instructions, la longueur des enregistrements est donnée par la variable de type integer selon les règles proposées : lf1 ou lf2 . Des clauses complémentaires peuvent se donner, voir la description complète de l'instruction. Il est recommandé de programmer les clauses par défaut pour les fichiers à accès direct afin de recon-naître immédiatement la nature du fichier. 6.3.1.2 ÉCRITURE D'UN FICHIER À ACCÈS DIRECT Tous les enregistrements d'un fichier à accès direct doivent posséder la même longueur, mais certains compilateurs admettent des enregistrements à longueur variable. L'accès aux enregistre-ments s'effectue par l'intermédiaire d'un numéro d'ordre, le premier enregistrement portant le numéro 1 . 1. Ecriture de données numériques codées (sans les clauses de traitement des erreurs) write (1,'(2f10.4,e12.5,2i8)',rec=l1) a,b,c,i,k

- écriture de données chaînes de caractères codées :

write (1,'(3a)',rec=l2) chain1,chain2,chain3

- écriture de données numériques et alphanumériques codées : write (1,'(2g12.5,a,2f10.3)',rec=l3) e,f,chain4,r,s

- La longueur des enregistrements est : pour a ,b ,c ,i ,k : 20 + 12 + 16 = 48 octets pour chain1 ,chain2 ,chain3 : 12 + 16 + 32 = 60 octets pour e ,f ,chain4 ,r ,s : 24 + 8 + 20 = 52 octets. 2. Ecriture de données numériques binaires (sans les clauses de traitement des erreurs)

write (1,rec=l4) a,b,c,i,k

- écriture de données chaînes de caractères binaires : write (2,rec=l5) chain1,chain2,chain3

- 167 -


- écriture de données numériques et alphanumériques binaires :

write (2,rec=l6) e,f,chain4,r,s

- La longueur des enregistrements est :

pour a ,b ,c ,i , k : 20 octets ou 5 mots pour chain1 ,chain2 ,chain3 : 60 octets ou 15 mots pour e ,f ,chain4 ,r ,s : 24 octets ou 6 mots. L'instruction d'écriture de données codées provoque les opérations suivantes : 1. lecture des données codées binaires de l'enregistrement interne, entrées au clavier ou affectation

interne, 2. traduction de ces données de code binaire en code ASCII donc en une suite de caractères confor-

mément aux spécifications des descripteurs de mise en forme, 3. écriture des données traduites dans un enregistrement externe en mode d'accès direct. Si la longueur de l'enregistrement transféré vers l'extérieur est inférieure à la capacité de la place prévue dans le fichier, l'enregistrement est complété par des espaces. Si la longueur est supérieure à la capacité, une erreur intervient dans le transfert. Dans l'écriture en code binaire en accès direct, la valeur en binaire de l'enregistrement interne est transférée vers l'enregistrement externe sans traduction, conformément aux éléments cités dans la liste, d'ou gain de temps et conservation de la précision numérique. Exemple : Initialisation d'un fichier en accès direct, données binaires, longueur 20 octets, affectation de 50 enregistrements de taille = 18 octets par enregistrement (FORTRAN DOMAIN ou MS).

* * Exemple 33 * Création d'un fichier à accès direct * program exem33 integer*2 i real*4 a,ai,b,c,d parameter (pi=3.141593) intrinsic cos,real,sin * write (*,'(//,15x,a,//)') 'FICHIER A ACCES DIRECT' open (8,file='enregi.duf',access='direct',status='unknown', + form='unformatted',recl=20) * do i=1,50 ai= real(i) * pi a = 2.5 * ai b = 10.0 * sin(0.05*ai) c = 20.0 * cos(0.1*ai) d = a - b + 2.0*c write (8,rec=i) i,a,b,c,d end do * print *,'--- Création du fichier : enregi.duf terminée ---' close (8) end 6.3.1.3 LECTURE D'UN FICHIER À ACCÈS DIRECT L'instruction générale de lecture est read accompagnée du numéro de l'unité logique, de la mise en forme pour les données codées, du numéro d'enregistrement à lire rec = ... , des clauses com-

- 168 -


plémentaires et de la liste des variables à affecter. Dans les exemples suivants, nous avons conservé la même liste de variables et la même longueur des enregistrements . 1. Lecture de données numériques codées (sans les clauses de traitement des erreurs) read (1,'(2f10.4,e12.5,2i8)',rec=n1) a,b,c,i,k

- lecture de données chaînes de caractères codées :

read (1,'(3a)',rec=n2) chain1,chain2,chain3

- lecture de données numériques et alphanumériques codées :

read (1,'(2g12.5,a,2f10.3)',rec=n3) e,f,chain4,r,s 2. Lecture de données numériques binaires (sans les clauses de traitement des erreurs)

read (2,rec=n4) a,b,c,i,k

- lecture de données chaînes de caractères binaires :

read (2,rec=n5) chain1,chain2,chain3

- lecture de données numériques et alphanumériques binaires :

read (2,rec=n6) e,f,chain4,r,s L'instruction de lecture en mode d'accès direct dans un fichier écrit codé ASCII engendre les opé-rations suivantes : 1. Lecture d'un ou de plusieurs enregistrements externes en mode d'accès direct, selon la configu-

ration du programme et le numéro de l'enregistrement, 2. traduction des caractères lus en code binaire en utilisant les descripteurs d'édition, 3. affectation des éléments traduits à la liste d'entrée dans l'ordre de lecture de gauche à droite. Exemple de lecture à accès direct : Prenons le fichier créé dans l'exemple précédemment et lisons les données en ordre quelconque selon les désirs de l'utilisateur. La variable entière i stockée dans le fichier sert au contrôle du pro-gramme. * * Exemple 34 * Lecture d'un fichier créé en accès direct * program exem34 integer*2 i,ienr logical lrep real*4 a,b,c,d character rep*1 * data lrep /.true./ * write (*,'(//,15x,a,//)') 'LECTURE D''UN FICHIER A ACCES DIRECT' * open (9,file='enregi.duf',access='direct',status='old', + form='unformatted',recl=20) * do while (lrep) write (*,'(/,5x,a,$)') + 'Quel enregistrement désirez-vous (<=50) ? ' read *,ienr

- 169 -


read (9,rec=ienr) i,a,b,c,d write (*,'(1x,i10,4f15.7)') i,a,b,c,d write (*,'(/,5x,a,$)') 'Encore un enregistrement (o/n) ? ' read (*,'(a1)') rep lrep = (rep .eq. 'o') .or. (rep .eq. 'O') end do * close (9) end Résultat de l'exécution du programme

LECTURE D'UN FICHIER A ACCES DIRECT Quel enregistrement désirez-vous (<=50) ? 7 7 54.9778700 8.9100660 -11.7557100 22.5564000 Encore une valeur (o/n) ? n L'instruction de lecture en code binaire permet donc de lire, en mode d'accès direct, un enregis-trement externe sans passer par une traduction. Les valeurs lues sont affectées aux éléments de la liste d'entrée dans l'ordre où ces éléments apparaissent, soit de gauche à droite. 6.3.2 UTILISATION D'UN FICHIER À ACCÈS DIRECT Les fichiers à accès direct présentent l'avantage de pouvoir atteindre n'importe quel enregistre-ment en lecture et en écriture à partir de toute position du pointeur dans le fichier. Nous voulons mon-trer un exemple partiel mettant en évidence les propriétés de ce genre de fichier. 6.3.2.1 PRÉSENTATION DE PROGRAMME Le programme principal se réduit au choix de sous-programmes, toutes les tâches sont exécutées dans les procédures de traitement. Le programme est écrit en MS-FORTRAN et se laisse facilement adapter et terminer dans l'implémentation à disposition. Il se compose : 1. d'un programme principal pour atteindre les procédures, 2. subroutine menu : affichage du menu 3. subroutine create : création du fichier à accès direct 4. subroutine introd : introduction des articles dans le fichier 5. subroutine lectur : lecture des enregistrements existants 6. subroutine modif : modification des enregistrements (non opérationnel) 7. subroutine inform : lecture des informations, voir exemple 31 8. subroutine efface : effaçage de l'écran 9. subroutine touche : pression sur une touche pour redémarrer l'exécution. 6.3.2.2 INSTRUCTIONS DU PROGRAMME Les instructions sont numérotées et proviennent du fichier engendré pendant la compilation, soit du fichier exem035.lst , ce fichier étant purgé des numéros de ligne. 1 * 2 * Exemple 35 3 * Traitement d'un fichier en accès direct 4 * 5 program exem35

- 170 -


6 integer*2 ipoint 7 external create,efface,inform,introd,lectur,menu,modif 8 * 9 10 call menu 10 read (*,*) ipoint 11 * 12 if (ipoint .eq. 1) then 13 call create 14 else if (ipoint .eq. 2) then 15 call introd 16 else if (ipoint .eq. 3) then 17 call lectur 18 else if (ipoint .eq. 4) then 19 call modif 20 else if (ipoint .eq. 5) then 21 call inform 22 end if 23 if ((ipoint .ge. 0) .and. (ipoint .le. 5)) goto 10 24 call efface 25 end 27 * 28 * Affichage du menu 29 * 30 subroutine menu 31 external efface 32 * 33 call efface 34 write (*,'(///,16x,a,//,2(14x,a,/)//,6(15x,a,/)//,18x,a,\)') 35 + 'CREATION ET GESTION D''UN FICHIER A ACCES DIRECT', 36 + 'Menu : Choisissez un des points du menu', 37 + ' ensuite pressez sur la touche <RET>', 38 + '1. Création du fichier', 39 + '2. Introduction des articles', 40 + '3. Lecture des articles', 41 + '4. Modifications des articles', 42 + '5. Informations sur le programme', 43 + '6. Fin de programme', 44 + ' Quel point adoptez vous ? ' 45 end

47 * 48 * Sous-programme create engendrant le fichier 49 * 50 subroutine create 51 integer*2 n 52 logical*2 lfile,lmarq 53 character*12 fiche 54 external efface,touche 55 * 56 data lmarq /.false./ 57 * 58 call efface 59 write (*,'(//,20x,a,//,5x,a,\)') 60 + 'CREATION DU FICHIER A ACCES DIRECT', 61 + 'Donnez le nom complet du fichier (<=12car) : '

- 171 -


62 read (*,'(a12)') fiche 63 * 64 inquire (file=fiche,exist=lfile) 65 if (.not. lfile) then 66 write (*,'(12x,a,\)') 'le nombre d''enregistrements : ' 67 read *, n 68 open (2,file=fiche,access='direct',recl=36,status='new') 69 do 10 i=1,n 70 write (2,rec=i) lmarq 71 10 continue 72 write (*,'(//,20x,a,//)') 'FIN DE LA CREATION' 73 close (2) 74 else 75 write (*,'(//,2(10x,a,/)/)') 76 + 'ATTENTION !!!','Le fichier existe dejà' 77 end if 78 * 79 call touche 80 * 81 end

83 * 84 * Introduction des éléments dans le fichier 85 * 86 subroutine introd 87 integer*2 n 88 logical*2 lcont,lfile,lmarq 89 character*16 cmot1,cmot2,cmot*32 90 character fiche*12,rep*1 91 external efface,touche 92 * 93 equivalence (cmot(1:16),cmot1),(cmot(17:32),cmot2) 94 data lmarq /.true./ 95 * 96 call efface 97 write (*,'(//,15x,a,//,5x,a,\)') 98 + 'INTRODUCTION DES ARTICLES DANS LES ENREGISTREMENTS', 99 + 'Donnez le nom complet du fichier (<=12car) : ' 100 read (*,'(a12)') fiche 101 * 102 inquire (file=fiche,exist=lfile) 103 * 104 if (lfile) then 105 write (*,'(//,10x,3a,//)') 106 + 'Le fichier ',fiche,' existe' 107 open (2,file=fiche,access='direct',recl=36,status='old') 108 n=1 109 10 read(2,rec=n,end=20) lcont 110 n=n+1 111 go to 10 112 20 n=n-1 113 write (*,'(/,10x,a,i4,a,/)') 114 + 'Ce fichier contient : ',n,' enregistrements' 115 30 write (*,'(/,5x,a,\)') 116 + 'Donnez le numéro de l''enregistrement : ' 117 read *, num

- 172 -


118 read (2,rec=num) lcont 119 if (lcont) then 120 write (*,'(/,5x,a,/)') 'Cet enregistrement est déjà occupé' 121 else 122 write (*,'(/,5x,a,\)') 123 + 'Donnez le 1ier texte de l''article : ' 124 read (*,'(a16)') cmot1 125 write (*,'(12x,a,\)') 126 + 'le 2ième texte de l''article : ' 127 read (*,'(a16)') cmot2 128 write (2,rec=num) lmarq,cmot 129 end if 130 * 131 write (*,'(5x,a,\)') 132 + 'Encore un enregistrement (o/n) ? ' 133 read (*,'(a1)') rep 134 if ((rep .eq. 'o') .or. (rep .eq. 'O')) goto 30 135 close (2) 136 * 137 else 138 write (*,'(//,2(10x,a,/)/)') 139 + 'Ce fichier est inconnu', 140 + 'Veuillez tout d''abord créer ce fichier' 141 end if 142 * 143 call touche 144 end

146 * 147 * Affichage des enregistrements du fichier 148 * 149 subroutine lectur 150 integer*2 n,num 151 logical*2 lfile,lmarq 152 character*32 cmot 153 character fiche*12 154 external efface,touche 155 * 156 call efface 157 write (*,'(//,15x,a,//,5x,a,\)') 158 + 'AFFICHAGE DES ENREGISTREMENTS EXISTANTS DANS LE FICHIER', 159 + 'Donnez le nom complet du fichier (<=12 car) : ' 160 read (*,'(a)') fiche 161 * 162 inquire (file=fiche,exist=lfile) 163 * 164 if (lfile) then 165 open (2,file=fiche,access='direct',recl=36,status='old') 166 write (*,'(//,15x,a,8x,a,14x,a,/)') 167 + 'Numéro','Texte 1','Texte 2' 168 n=1 169 num=0 170 10 read (2,rec=n,end=20) lmarq 171 if (lmarq) then 172 num=num+1 173 read (2,rec=n) lamrq,cmot

- 173 -


174 write (*,'(15x,i6,2(5x,a16))') n,cmot(1:16),cmot(17:32) 175 if (mod(num,5) .eq. 0) print * 176 end if 177 n=n+1 178 goto 10 179 20 continue 180 close (2) 181 else 182 write (*,'(//,a,//)') 183 + 'Ce fichier n''existe pas' 184 end if 185 * 186 187 call touche 188 end

190 * 191 * Modification des enregistrements 192 * 193 subroutine modif 194 external efface,touche 195 call efface 196 call touche 197 end 199 * 200 * Affichage des informations (voir exemple 31) 201 * 202 subroutine inform 203 external efface,touche 204 call efface 205 call touche 205 end 207 * 208 * Effacement de l'écran 209 * 210 subroutine efface 211 intrinsic char 212 write (*,'(1x,a1,a2,a1,a3)') char(27),'[H',char(27),'[2J' 213 end 215 * 216 * Sous-programme d'arrêt et de pression sur la touche <RET> 217 * 218 subroutine touche 219 character*1 rep 220 write (*,'(/,10x,a,\)') 221 c 'Pour continuer, pressez sur la touche <RET> ' 222 read (*,'(a1)') rep 223 end 6.3.2.3 PARTICULARITÉS DES INSTRUCTIONS Chaque procédure : d'initialisation, d'introduction et de lecture, effectue une ouverture du fichier à accès direct. Donnons quelques informations complémentaires sur la fonction des diverses instruc-tions du programme, ligne après ligne.

- 174 -


1. Programme principal ligne 9 : Appel du sous-programme menu ligne 10 : lecture du point choisi dans le menu ligne 12 : début du bloc if permettant d'atteindre chaque tâche du programme ligne 23 : répétition de l'appel du menu tant que ipoint <= 5 ligne 45 : si ipoint à l'extérieur du domaine de définition, fin de programme 2. Sous-programme menu ligne 34 : début de l'affichage après l'effaçage de l'écran ligne 44 : attente sur le choix du point adopté 3. Sous-programme create ligne 56 : initialisation de la variable lmarq à .false. ligne 64 : contrôle de la présence du fichier dans le répertoire ligne 65 : si le fichier n'existe pas, il peut être initialisé ligne 68 : ouverture du fichier en accès direct avec 36 octets par enregistrement ligne 70 : marquage de chaque enregistrement sur les 2 premiers octets ligne 73 : fermeture du fichier 4. Sous-programme introd ligne 93 : équivalence entre les variables cmot1 , cmot2 et cmot ligne 102 : contrôle de l'existence du fichier à ouvrir ligne 107 : ouverture du fichier si présent dans le répertoire ligne 109 : lecture du fichier complet et décompte du nombre d'enregistrements ligne 115 : Introduction du numéro d'enregistrement à affecter ligne 119 : Si le fichier est marqué par une valeur .true. , alors pas de possibilité d'introduire un

nouvel enregistrement ligne 121 : Sinon, possibilité d'introduire un enregistrement ligne 128 : Transfert de la marque .true. et du mot complet cmot dans l'enregistrement. La

variable cmot contient les deux affectations à cmot1 et cmot2 grâce à l'équi-valence

ligne 135 : fermeture du fichier 5. Sous-programme lectur ligne 162 : contrôle de l'existence du fichier à ouvrir ligne 164 : si fichier existant alors : ligne 165 : ouverture du fichier en accès direct ligne 170 : lecture des enregistrements par ordre croissant ligne 171 : si marque de début de fichier est égale à .true. alors : ligne 173 : lis pour cet enregistrement : la marque et le mot de 32 octets ligne 174 : écris : le numéro d'enregistrement, les 16 premiers octets de cmot , les 16 octets

suivants de la même variable ligne 175 : laisse un ligne blanche après 5 lignes d'écriture ligne 180 : fermeture du fichier ligne 181 : sinon si le fichier n'existe pas, alors écris une mise en garde L'existence du fichier est repérée sur le disque au moyen de l'instruction inquire . Lors de la création du fichier, tous les débuts des enregistrements sont marqués par une valeur logique valant .false. . Lors de l'enregistrement des valeurs introduites, le programme va tout d'abord lire ce mar-quage et va changer l'état de cette donnée en .true. lorsque les données alphanumériques sont transférées dans l'enregistrement. Si le marquage est .true. , il n'est pas possible de placer de nou-velles données dans l'enregistrement. Le sous-programme modif devrait permettre de prévoir les modifications sur les enregistrements présents.

- 175 -

CHAPITRE 7

REPRÉSENTATIONS GRAPHIQUES Ce chapitre traite principalement de la programmation en FORTRAN, des instructions graphiques pour le traceur HP 7475 A et de l’utilisation du langage Adobe PostScript dans la construction des graphiques à l’écran et sur papier. Le langage FORTRAN ne contient aucune instruction pour générer des images soit à l’écran, soit sur un périphérique.

7.1 GRAPHIQUES SUR TRACEUR HP 7475 A Les constructions graphiques sur papier peut s'effectuer au moyen d'un traceur, d'un programme et d'un protocole de communication entre ces composantes. Le but de ce sous-chapitre est de présenter quelques caractéristiques du traceur, les commandes du langage du traceur et quelques programmes d'application. Une description plus complète des possibilités de ce traceur, des instructions du langage et des applications est donnée dans tous les manuels des constructeurs. 7.1.1 DESCRIPTION DU TRACEUR HP 7475 A Le traceur HP 7475 A est un traceur à 6 plumes permettant d'obtenir des dessins aux formats européens A3 et A4, américains A et B . Ce traceur utilise des commandes en langage graphique HP-GL : Hewlett-Packard Graphic Language. 7.1.1.1 SYNTAXE DU LANGAGE HP-GL Une instruction HP-GL se compose d'un mnémonique de deux lettres, suivi éventuellement d'une zone de paramètres et d'un terminateur. Une instruction se termine par le point-virgule si le mode de communication est RS-232-C avec le traceur. La configuration générale d'une instruction est : XX paramètres [,paramètres] terminateur Instruction ; pour traceur sur RS-232-C paramètres optionnels Certaines instructions ont des paramètres optionnels qui prennent des valeurs par défaut. L'ins-truction d'écriture de texte alphanumérique LB doit s'achever par le caractère ASCII ETX, soit le char(3) . Les zones de paramètres doivent se spécifier au format défini par la syntaxe de l'instruction. 1. entiers : entre -32768 et +32767, les parties décimales des paramètres étant tronquées; 2. décimal : entre -128.0000 et +127.9999 avec partie décimale ayant éventuellement plus de 4 chif-

fres significatifs; 3. décimal cadré : entre -32768.0000 et + 32767.0000 avec partie décimale ayant éventuellement

plus de 4 chiffres significatifs; 4. texte alphanumérique : toute combinaison de chaîne de caractères. Les instructions, codées ASCII, doivent se transmettre vers le traceur .

- 176 -

- 7. Constructions graphiques et implémentation en Fortran 77 -

7.1.1.2 ZONE DE TRAÇAGE La zone de traçage est la partie du papier sur laquelle le traceur peut dessiner. Une unité traceur vaut : 25,4 mm : 1024 parts = 0,0248 mm . Les zones de traçage métriques sont : Format A3 : Axe X : 0 à 16158 unités, axe Y : 0 à 11040 unités Axe X : 400,8 mm axe Y : 273,8 mm Format A4 : Axe X : 0 à 11040 unités, axe Y : 0 à 7721 unités Axe X : 273,8 mm axe Y : 191,5 mm Le point origine est au coin inférieur gauche, en l'absence d'un ordre de rotation des axes. 7.1.1.3 SYTÈMES D'UNITÉS Deux systèmes d'unités sont à disposition : les unités du traceur et les unités définies par l'uti-lisateur. 1. Unités du traceur L'unité traceur représente le plus petit déplacement incrémental de la plume, soit 0,024805 mm . Les paramètres entiers des instructions en unité traceur sont compris entre -32768 et +32767. 2. Unités de l'utilisateur L'utilisateur a la possibilité de fixer ses propres unités, unités qui peuvent prendre n'importe quelle valeur pour autant que la gamme des valeurs décimales, dans tous les cas de définition, soit com-prise dans la fourchette -32768.0000 et +32767.0000 . 7.1.1.4 POINTS DE CADRAGE A la mise sous tension du traceur, l'emplacement des points de cadrage P1 est près du point ori-gine, le point P2 étant diamétralement opposé. Les valeurs par défaut sont :

Tableau 7.1 POINTS DE CADRAGE PAR DÉFAUT HP 7475 A

- Format - Point de cadrage par défaut en unités traceur . P1(x) P1(y) P2(x) P2(y)

A3 A4

170 602 15370 10602 603 521 10603 7721

7.1.2 INSTRUCTIONS GRAPHIQUES Le tableau 7.4 donne la syntaxe des diverses commandes du traceur. Ces instructions graphiques sont données par ordre alphabétique avec la liste des paramètres et une brève description de leur fonction. Les mnémoniques des commandes, par exemple PU pour « pen up » en anglais, sont écrits en caractères gras.

- 177 -


Tableau 7.2 SYNTAXE DES INSTRUCTIONS HP-GL POUR HP 7475 A

Instruction Signification

AA x,y,ang[,angc] AR x,y,ang[,angc] CA N CI ray[,angc] CP esp,lig

Arc absolu, centre à : x,y angle au centre : ang; angle corde : angc Arc relatif, incréments du centre : x,y angle au centre : ang; angle corde : angc Jeu de caractères secondaire, par défaut 0 0-4, 6-9 ou 30-39 Traçage d'un cercle rayon : ray ; angle au centre : angc Déplace la plume de : espaces : esp; lignes : lig

CS M DC DF DI horiz,vertic DP

Jeu de caractères standard, par défaut 0 0-4, 6-9 ou 30-39 Supprime la numérisation Remet les fonctions aux valeurs par défaut Définition de la direction d'écriture composantes : horiz et vertic Place le traceur en mode numérisateur

DR hor DT

iz,vertic

t EA x,y ER x,y EW

ray,ang0,angd

Définition de la direction relative composantes : horiz et vertic Définition du terminateur d'écriture symbole proposé par l'utilisateur : t Traçage des côtés d'un rectangle absolu coordonnées absolues : x et y Traçage des côtés d'un rectangle relatif incrément : x et y Traçage des côtés d'un secteur circulaire de rayon : ray; angle initial : ang0; angle décrit : angd

FT [ty IM

p[,esp[,ang]]]

val IN

E[,valS[,valP]]

IP p1x IW

,p1y[,p2x,p2y]

xa1,ya1,xs2,ys3

Définition du type de remplissage sélection : typ , type de remplissage Entrée du masque contrôle des erreurs de masque Initialisation les fonctions du traceur Positionne les points de cadrage Positionne les points de cadrage Définition de la fenêtre graphique spécifie les coordonnées des coins

LB LT num OA

[,long]

OC OD

Ecriture d'un texte chaîne de caractères Définition du type de ligne numéro du motif : num Transmet la position réelle de la plume Transmet la position commandée de la plume Transmet l'état de la plume et le dernier point .

OE OF OH OI OO

Transmet les erreurs HP-GL Transmet les facteurs Transmet les limites mécaniques Transmet l'identification du traceur Transmet les caractéristiques du traceur

OP OS OW

Transmet les erreurs HP-GL Transmet les facteurs Transmet les limites mécaniques

- 178 -


Tableau 7.2 (suite) SYNTAXE DES INSTRUCTIONS HP-GL POUR HP 7475 A

Instruction Signification

PA x1,y1, ... PD PR y1,y,1 ... PS Param PT Larg PU RA x,y

Traçage absolu . coordonnées : x1 et y1 , ... etc Descend la plume Traçage relatif incréments : x1,y1, ... etc Modification du format du papier graphique format du papier : param Définition de la largeur de la plume espace entre les lignes : larg Montée de la plume Traçage des ombres d'un rectangle absolu coordonnées : x et y

RO angle RR x,y SA SC xmin,xmax,ymin,ymax SI larg,haut

Rotation du système de coordonnées angle de rotation : 0 ou 90 Traçage des ombres d'un rectangle relatif incréments : x et y Sélection du jeu de caractères secondaire Cadrage : coordonnées de l'utilisateur limites sur l'axe Ox : xmin,xmax limites sur l'axe Oy : ymin,ymax Dimension absolue des caractères largeur : larg; hauteur : haut

SL tang SM carac SP nump SR larg,haut SS TL Tp[,tn]

Inclinaison des caractères inclinaison : tangente de l'angle : tang Traçage en mode symbole caractère utilisé : carac Sélection de la plume numéro de la plume : nump (0 à 6) Dimension relative des caractères largeur : larg; hauteur : haut Sélection du jeu de caractères standard Définition de la longueur des graduations longueur des traits : tp et tn en %

UC x,y VS param

Définition des caractères de l'utilisateur dessine les caractères utilisateur Vitesse de la plume paramètre : param = de 0 à 127.9999

7.1.3 EXEMPLES DE GRAPHIQUES Les exemples proposés servent à illustrer les instructions principales du langage graphique HP-GL dans la configuration d’un programme FORTRAN. Les représentations graphiques de ce cours sont créées en plusieurs étapes : 1. Création d'un fichier de commandes HP-GL au moyen du programme FORTRAN ; 2. Instructions de communication entre l'ordinateur et le traceur ; 3. Dessin des graphiques. Les exemples proposés sont programmés pour la version MS-FORTRAN sur micro-ordinateurs. De légères modifications et améliorations peuvent s'effectuer pour adapter les instructions aux autres versions du langage.

- 179 -


7.1.3.1 PROCÉDURE D'INITIALISATION Les langages de programmation comme FORTRAN permettent de créer des sous-programmes effectuant une tâche dans la construction des graphiques. Le premier exemple donne la procédure générant l'initialisation du traceur dans les formats A3 ou A4. Deux procédures complémentaires permettent d'effectuer les deux opérations fondamentales des graphiques : tracer un trait et déplacer la plume. * * Exemple 36 * ************************************************************* * * Sous programme d'initialisation du traceur HP 7475 A * Les commandes graphiques sont transmises par l'unité logique 3 * Le nom du fichier est choisi par l'utilisateur conformément à la * syntaxe du système d'exploitation. * subroutine initra integer iforma character fichi*32 * * Effaçage de l'écran et affichage du titre de la tâche * write (*,'(2a1,a2,a1,a3,///,14x,a,///)') + ' ',char(27),'[H',char(27),'[2J', + 'INITIALISATION DU TRACEUR HP 7475 ET CHOIX DU FORMAT' write (*,'(15x,a,//,6x,a,/,6x,a,//,9x,a,\)') + 'CHOIX DU FORMAT DU PAPIER','1. Format A3 : 420 x 297 mm', + '2. Format A4 : 297 x 210 mm','Quel point adoptez-vous ? ' read *, iforma * * Choix du nom du fichier : jusqu'à 32 caractères * write (*,'(/,6x,a,\)') c 'Donnez le nom complet du fichier de commandes : ' read (*,'(a)') fichi * * Ouverture du fichier de commande * open (3,file=fichi,status='unknown',access='sequential', + form='formatted') * * Définition des points de cadrage pour formats A3 ou A4 * Unités utilisateur (correspondent aux mm sur format A3): * Axe Ox : 0.00 à 385.00 (mm) * Axe Oy : 0.00 à 270.00 (mm) * write (3,'(a)') 'IN;' write (3,'(a)') 'VS 6;' if (iforma .eq. 1) then write (3,'(a)') 'PS 1;IP 318,77,15840,10962;' else write (3,'(a)') 'PS 4;IP 77,87,10962,7721;' end if write (3,'(a)') 'SC 0,385,0,270;'

- 180 -


* end * ***************************************************************** * * Subroutine move (x,y) * Déplacement de la position actuelle à la position données par les * coordonnées absolues x,y (traceur ou utilisateur) * subroutine move (x,y) real*4 x,y write (3,'(a)') 'PU;' write (3,'(2(a,f8.2),a1)') 'PA ',x,',',y,';' end * ***************************************************************** * * Subroutine draw (x,y) * Dessin d'un trait de la position actuelle à la position donnée * par les coordonnées absolues x,y (traceur ou utilisateur) * subroutine draw (x,y) real*4 x,y write (3,'(a)') 'PD;' write (3,'(2(a,f8.2),a1)') 'PA ',x,',',y,';' end Les unités utilisateurs peuvent être modifiées à volonté, soit en introduisant d'autres paramètres numériques dans l'instruction, soit par l'intermédiaire de variables numériques réelles dont la valeur est affectée en mode interactif. 7.1.3.2 DIRECTION DE L'ÉCRITURE Cet exemple simple montre l'écriture d'un texte élémentaire selon des directions différentes avec un incrément de 30°. La procédure d'initialisation est placée dans un fichier pouvant se nommer par exemple : GRAFINIT.FOR . Par contre, ce programme n'utilise pas les deux sous-programmes : draw et move , mais directement les mnémoniques du tableau. Il fait usage de la routine initra de l’exemple précéedent. * * Exemple 37 * Programme graphique permettant de dessiner un texte sous * plusieurs angles avec un incrément de 30° * program exem37 integer i,phideg real*4 phi,co,si,x0,x,y0,y,r parameter (pi=3.141593) intrinsic cos,sin external initra * call initra write (3,'(a)') 'SP 1;' write (3,'(a)') 'PU 10,10;' write (3,'(a)') 'PD 10,260,370,260,370,10,10,10;' write (3,'(a)') 'PU 190,135;'

- 181 -


write (3,'(a)') 'SR 0.8,1.6;' * x0=190.0 y0=135.0 r = 16.0 * do i=0,11 phi=i*pi/6.0 phideg=30*i si=sin(phi) co=cos(phi) x=x0+r*co y=y0+r*si write (3,'(2(a,f7.4),a)') 'DI ',co,',',si,';' write (3,'(2(a,f6.2),a)') 'PU ',x,',',y,';' write (3,'(a,i3,a,a1)') c 'LBDIRECTION ',phideg,' degres',char(3) end do * write (3,'(a)') 'SP 0;' close(3) * end

Dessin de l’écriture sous plusieurs inclinaisons 7.1.3.3 REPRÉSENTATION D'UNE FONCTION Cet exemple trace la courbe y = sin(x)/x pour x compris entre -4 pi et + 4 pi par incrément de 0,05 pi . La surface comprise entre l'axe horizontal et la courbe est hachurée verticalement en chaque point calculé. Il utilise à nouveau l’initialisation du traceur par la routine initra.

- 182 -


* * Exemple 38 * Programme graphique permettant de tracer la courbe sin(x)/x * sur format A3 ou A4 * program exem38 * integer i real*4 facx,facy,valeur real*4 x,x0,xgraf,y,y0,ygraf,yprov character*16 forme parameter (pi = 3.141593) intrinsic cos,sin external initra * * Version utilisant une constante chaîne de caractères * pour la mise en forme des données * data forme /'(2(a,f6.2),a)'/ * call initra write (3,'(a)') 'SP 1;' write (3,'(a)') 'PU 10,10;' write (3,'(a)') 'PD 10,260,370,260,370,10,10,10;' write (3,'(a)') 'PU 60,50;' write (3,'(a)') 'PD 60,250,360,250,360,50,60,50;' write (3,'(a)') 'PU 60,100;' write (3,'(a)') 'PD 360,100;' write (3,'(a)') 'PU 210,50;' write (3,'(a)') 'PD 210,250;' write (3,'(a)') 'PU 60,100;' write (3,'(a)') 'SR 1.5,3.0;' * x0=210.0 y0=100.0 yprov=y0 facx=300.0/(8.0*pi) facy=100.0 * do i=-80,80 x=i*pi/20.0+1E-10 y=sin(x)/x xgraf=x0+x*facx ygraf=y0+y*facy write (3,forme) 'PD ',xgraf,',',ygraf,';' write (3,forme) 'PU ',xgraf,',',y0,';' write (3,forme) 'PD ',xgraf,',',ygraf,';' end do * write (3,'(a)') 'PU 60,50;' * do i=-1,3 xgraf=60.0 ygraf=y0+i*50.0-1 valeur=0.5*i write (3,forme) 'PU ',xgraf,',',ygraf,';'

- 183 -


write (3,'(a)') 'CP -4.5,0.0;' write (3,'(a,f4.1,a1)') 'LB',valeur,char(3) end do * write (3,'(a)') 'PU 60,50;' write (3,'(a)') 'DI 0.0,-1.0;' * do i=-4,4 xgraf=x0+i*37.5-1.0 ygraf=47.0 write (3,forme) 'PU ',xgraf,',',ygraf,';' write (3,'(a,i2,a,a1)') 'LB',i,' PI',char(3) end do * write (3,'(a)') 'DI;' write (3,'(a)') 'SR 2.0,4.0;' write (3,'(a)') 'PU 80,220;' write (3,'(a,a1)') 'LBSINUS(X)/X',char(3) write (3,'(a)') 'PU;' write (3,'(a)') 'SP 0;' close(3) * end

Dessin de de la fonction sin(x) / x entre – 4 pi et + 4 pi

7.1.3.4 REPRÉSENTATION D'UNE COURBE FERMÉE L'exemple montre la programmation d'une grille avec valeurs sur les deux axes de coordonnées, l'écriture du titre centré et le tracé de la courbe à partir des deux équations paramétriques : x = 1,6 sin( t ); y = 1,2 cos(1,5 t ). La courbe est construite pour un paramètre t variant de 0 à 4 pi par incrément de 0,02 pi . Afin d'as-surer sûrement la fermeture de la courbe, le nombre d'incréments est choisi égal à 201.

- 184 -


* * Exemple 39 * Programme permettant de tracer une courbe fermée par deux * fonctions paramétriques * program exem39 integer i real*4 xgraf,x0,ygraf,y0 real*4 facx,facy,t,valeur intrinsic char,cos,sin external draw,initra,move * call initra write (3,'(a)') 'SP 1;' write (3,'(a)') 'PU 10,10;' write (3,'(a)') 'PD 10,260,370,260,370,10,10,10;' * write (3,'(a)') 'PU 60.0,25.0;' write (3,'(a)') 'PD 60,235,340,235,340,25,60,25;' * facx=280/4 facy=210/3 x0=60.0+2.0*facx y0=25.0+1.5*facy write (3,'(a)') 'SR 0.7,1.4;' * do i=-3,3 xgraf=60.0 ygraf=y0+0.5*i*facy valeur=0.5*i call move (xgraf,ygraf) write (3,'(a)') 'CP -4.5,-0.25;' write (3,'(a,f4.1,a1)') 'LB',valeur,char(3) call move (xgraf,ygraf) xgraf=340.0 call draw (xgraf,ygraf) end do * do i=-4,4 valeur=0.5*i xgraf=x0+0.5*i*facx ygraf=y0-1.5*facy call move (xgraf,ygraf) write (3,'(a)') 'CP -2.0,-0.9;' write (3,'(a,f4.1,a1)') 'LB',valeur,char(3) call move (xgraf,ygraf) call draw (xgraf,235.0) end do * call move (200.0,235.0) write (3,'(a)') 'SR 1.5,3.0;' write (3,'(a)') 'CP -11.5,0.5;' write (3,'(a,a1)') 'LBEQUATIONS PARAMETRIQUES',char(3) * write (3,'(a)') 'SP 3;' xgraf=x0

- 185 -


ygraf=y0+1.2*facy call move (xgraf,ygraf) * do i=0,201 t=0.06283185*i xgraf=x0+(1.6*sin(t))*facx ygraf=y0+(1.2*cos(1.5*t))*facy call draw (xgraf,ygraf) end do * write (3,'(a)') 'SP 0;' close (3) * end

Dessin de la courbe fermée donnée sous forme paramétrique

7.1.3.5 REMARQUES COMPLÉMENTAIRES Les trois exemples proposés ici démontrent la complexité de la programmation en FORTRAN de représentations simples. Le résultat de la première écriture des instructions donnent rarement satis-faction au créateur des dessins. L’expérience de l’enseignement de l’informatique technique a montré que les collections de com-mandes pour les constructions graphiques varient constamment d’une version à l’autre du système d’exploitation et du logiciel. La duré de vie des codes « source » est très courte. De plus, les écrans et les traceurs ou imprimantes exigent des commandes différentes. C’est dans l’utilisation de logiciels de calculs au moyen de la méthode des éléments finis, MEF, que la solution la plus simple a vu jour. Par exemple, le logiciel ANSYS pouvait s’implémenter sur de nombreux systèmes d’exploitation et des calculateurs allant du micro-ordinateur au super calculateur comme le Cray. Le même fichier de don-nées tournait à l’écran et sur toutes les imprimantes graphiques. La suite de ce cours introduit un langage de description utilisable soit pour l’écran, soit pour les imprimantes. Il s’agit du langage PostScript créé par Adobe Systems Incorporated.

- 186 -


7.2 LANGAGE POSTSCRIPT™ Le langage de programmation PostScript permet de décrire n’importe quelle construction gra-phique à l’écran et sur une imprimante graphique. Le code nécessaire se trouve stocké dans un fichier de type texte et peut s’éditer soit manuellement, commande après commande, soit à l’aide d’un programme à l’aide d’opérateurs graphiques. Contrairement aux graphiques définis par les points de l’écran, comme les fichiers Paint * * * .bmp de Windows, les représentations graphiques peuvent s’adapter au format du papier sans perdre la précision des géométries. Les commandes présentées ici représentent seulement 20% du langage. 7.2.1 BASES DU LANGAGE Les programmes PostSript sont écrits en caractères minuscules ASCII imprimables. Ils sont donc lisibles par pratiquement tous les systèmes informatiques et ne dépendent pas du matériel utilisé. Le travail avec ce langage nécessite les opérations suivantes : 1. Ecriture d’un fichier contenant toutes les commandes graphiques avec les définitions fondamen-

tales et les tracés, textes, échelles, orientations désirés. 2. Transfert du fichier texte dans un logiciel écran capable de traiter les commandes afin d’afficher le

résultat de la lecture. 3. Si désiré, ce qui est le plus souvent le cas, impression du graphique sur papier au moyen d’une

imprimante à partir du logiciel de lecture ou transfert du graphique par exemple vers un logiciel de traitement de texte.

Le texte de ce chapitre va permettre de construire des graphiques lignes et surfaces simples sans entrer sur toutes les possibilités du langage. Indiquons immédiatement une particularité importante de ce langage et de son fichier texte : Pour obtenir une représentation graphique à l’écran ou sur un imprimante, aucune erreur n’est permise dans le fichier texte.

Très important Pour obtenir une représentation graphique à l’écran ou sur un imprimante, Aucune erreur n’est permise dans le fichier texte.

Cette remarque n’est pratiquement jamais citée dans les ouvrages traitant du sujet. 7.2.1.1 UNITÉS GRAPHIQUES Tous les tracés de lignes et de surfaces nécessitent la définition de points au moyen des coordonnées. Le point origine (x = 0 et y = 0) se trouve dans le coin inférieur gauche de la feuille appelée page courante. La position d’un point P se donne au moyen de ces deux grandeurs à une échelle soit dans les unités graphiques de PostScript, soit dans les unités utilisateur. 1. Unité graphique PostScript Comme le langage PostScript a été créé et développé aux USA, l’unité graphique fondamentale est basée sur le pouce : 1’’ = 25,4 mm. L’unité graphique vaut la 72ème partie d’un pouce, soit :

1 unité PostScript = 25,4 mm / 72 = 0,35278 mm. Cette unité est relativement grossière et ne permet pas de dessiner soit des courbes, soit des surfaces avec une précision suffisante. 2. Unité graphique utilisateur Il est possible de modifier la dimension de l’unité graphique en introduisant la commande d’échelle sur les deux axes de dessin afin de fixer les coordonnées utilisateur :

- 187 -


sx sy scale avec : sx sy facteurs d’échelle sur l’axe Ox et sur l’axe Oy. scale l’identificateur de la commande Particularité PostScript Dans les commandes PostScript, toutes les valeurs à affecter à la commande sont toujours pré-fixées. Exemples : 0.141732 0.141732 scale

Cette commande permet de modifier l’unité de base en une unité utilisateur, soit : 1 unité utilisateur axe O x = 0,35278 mm . 0,141732 = 0,05 mm. 1 unité utilisateur axe O y = 0,35278 mm . 0,141732 = 0,05 mm. Nous utiliserons ce facteur ou sa moitié 0.070866 dans les exemples proposés ici sur un graphi-que couvrant le format A4, 210 mm x 297 mm en position portrait ou paysage. Cette dimension métrique permet de positionner les lignes, les textes et les surfaces avec une précision de 0,05 mm en introduisant des coordonnées entières de type interger. En changeant manuellement ces deux facteurs dans le fichier texte, il est ainsi possible de modifier toutes les dimensions des figures, sans diminuer la précision du dessin. 3. Surface active La construction graphique sur la feuille A4 ne doit en aucun cas dépasser la limite du papier. La commande générale de limitation des tracés dans la surface rectangulaire est :

%%BoundingBox: x0 y0 x1 y1 avec : x0,y0 position du point origine par rapport à la valeur par défaut en unité PostScript. x1,y1 position du point diamétralement opposé en unité PostScript. Pour occuper la plus grande partie de la surface de la feuille A4, les grandeurs entières des coordonnées sont : Point origine : x0 = 0 et y0 = 0 . Point maximal : x1 = 590 et y1 = 840 . Avec ces deux dernières valeurs, la surface active prend les dimensions : Largeur du format sur A4 : (590 - 0) . 25,4 mm / 72 = 208,14 mm (210 mm). Hauteur du format sur A4 : (840 – 0) . 24,5 mm / 72 = 296.33 mm (297 mm). La directive de création de la surface active devient ainsi :

%%BoundingBox: 0 0 590 840 Cette directive se donne généralement sur la deuxième ligne des commandes. 4. Version du langage Postscript La version du langage PostScript se donne sur la première ligne des instructions. La version introduite dans les exemples porte le numéro 2. Cette directive s’écrit :

%!PS-Adobe-2.0 EPSF-2.0 7.2.1.2 PILE DANS POSTSCRIPT Le langage PostScript accumule toutes les commandes dans une partie de la mémoire appelée pile. Les commandes et les variables sont placées successivement sur la pile. La dernière grandeur introduite dans la pile est la première à être retirée. La pile est limitée en dimension et ne peut traiter un nombre très grand de données. Par exemple, le tracé d’une courbe mathématique au moyen de segments rectilignes entre des points successifs exige une limitation du nombre de points à 150 environ.

- 188 -


Comme cet exposé sur PostScript se limite aux opérations élémentaires, il ne traitera pas en détail les manipulations et les diverses instructions possibles sur la pile. Les opérateurs sur la pile sont les suivants :

clear: Retire tous les objets de la pile. dup Duplique l’objet situé au sommet de la pile. pop Retire l’objet situé au sommet de la pile et rend accessible l’objet suivant. roll permute le contenu de la pile. pstack Affiche le contenu de la pile. 7.2.1.3 OPÊRATEURS MATHÉMATIQUES Les opérateurs mathématiques effectuent les opérations usuelles sur des nombres entiers et réels décimaux appelés opérandes. Le tableau 7.3 donne ces opérateurs dans l’ordre alphabétique. Dans l’utilisation technique, la plupart des opérations arithmétiques sont effectuées dans le programme FORTRAN et non au moyen des opérateurs cités ci-après.

Tableau 7.3 OPÉRATEURS MATHÉMATIQUES POSTSCRIPT

Instruction PostScript Description

n1 abs n1 n2 add n1 n2 atan n1 ceiling n1 cos n1 n2 div

Valeur absolue de n1 Addition : n1 + n2 Arc tangente de n1/n2 Entier supérieur ou égal à n1 Cosinus de n1 exprimé en degrés n1 divisé par n2

n1 exp n1 floor i1 i2 idiv n1 ln n1 log i1 i2 mod

Exponentielle de n1 Entier < ou = à n1 Division entière de i1 par i2 Logarithme naturel de n1 Logarithme décimal de n1 i1 modulo i2

n1 n2 mul n1 neg - rand n1 round - rrand n1 sin

n1 multiplié par n2 Signe opposé pour n1 Génération aléatoire d’entiers Partie entière de n1 Entier initialisation du générateur Sinus de n1 exprimé en degrés

n1 sqrt i1 arand n1 subn2 n1 truncate

Racine carrée de n1 Initialise le générateur Soustraction : n1 – n2 Elimine la partie décimale de n1

n1 n2 nombres décimaux réels i1 i2 nombres décimaux entiers

Le langage PostScript utilise la représentation usuelle des nombres décimaux entiers ou réels, la virgule étant remplacée par le point.

- 189 -


7.2.1.4 GRAPHIQUES ÉLÉMENTAIRES La construction graphique s’effectue sur la page courante au moyen de commandes très simples comme celles du traceur précédent : déplacement d’un point à un autre, tracé d’un segment rectiligne d’un point à un autre. L’ensemble des segments de droite et des courbes est nommé chemin.

Tableau 7.4 OPÉRATEURS ÉLÉMENTAIRES DE DESSIN


Closepath x1 y1 lineto x1 y1 moveto newpath

Ferme le chemin courant par un segment rectiligne Trace une ligne jusqu’à x1, y1 Déplace le pointeur jusqu’à x1, y1 Efface le chemin courant

dx1 dy1 rlineto dx1 dy1 rmoveto fill n1 setgray

Trace une ligne incrément dx1, dy1 Déplace le pointeur incrément dx1,dy1 Remplit le chemin courant Fixe la couleur grise courante par n1

N1 setlinewith stroke showpage

Fixe l’épaisseur du trait à n1 Tracer le chemin courant Transmet la page courante au périphérique

Opérandes : x1, y1 coordonnées dans le plan dx1, dy1 déplacement incrémental depuis la position courante

1. Tracé d’une ligne Pour tracer un seul segment de droite d’un point P1 de coordonnées (x1,y1) à un point P2 de coor-données (x2,y2), il faut : 1. Effacer toute trace de chemin (newpath) 2. Positionner le pointeur aux coordonnées de départ (x1,y1) , (moveto). 3. Tracer la ligne du point P1 au point P2 en donnant les coordonnées (x2,y2), (lineto) . 4. Tracer le chemin courant, (stroke) 5. Transmettre ces opérations au périphérique, (showpage). Les déplacements du pointeur et les tracés d’un segment de droite peuvent se commander soit en introduisant les coordonnées du point terminal, soit en donnant les incréments selon les directions Ox et Oy à partir de la position du pointeur : Δx1 = x2 – x1 et Δy1 = y2 – y1. 2. Tracé d’une figure fermée Le tracé d’une figure fermée peut se programmer en déplaçant le tracé des segments de droite de telle sorte que les coordonnées du point de fermeture correspondent à celles du point de départ. La commande closepath effectue élégamment cette opération. Exemple : Soit à construire les deux lignes brisées représentées sur la figure ci-après, le première étant ouverte, la deuxième étant fermée. Programmation manuelle dans un éditeur de texte Ligne ouverte Ligne fermée newpath newpath 50 200 moveto 50 200 moveto 30 60 rlineto 30 60 rlineto 30 –60 rlineto 30 -60 rlineto 30 60 rlineto 30 60 rlineto

- 190 -


30 –60 rlineto 30 -60 rlineto 30 60 rlineto 30 60 rlineto 30 –60 rlineto 30 -60 rlineto 2 setlinewith 0 –60 rlineto stroke -120 0 rlineto

showpage closepath 2 setlinewith stroke showpage

Ligne brisée ouverte et ligne brisée fermée

3. Niveaux de gris des traits et des surfaces La commande n1 setgray permet d’obtenir toutes les nuances de gris comprises entre le noir et le blanc. Le gris et les diverses couleurs s’obtiennent par sommation des composantes RGB (rouge, vert bleu). La syntaxe et la fonction de cette commande sont :

n1 setgray avec : n1 une grandeur réelle comprise entre zéro et un, avec : n1 = 0 couleur noire (R = 0.0, G = 0.0 et B = 0.0), valeur par défaut, d’où lignes en noir. n1 = 1 couleur blanche (R = 1.0, G = 1.0 et B = 1.0). Les gris intermédiaires, du blanc au noir, sont la sommation des composantes RGB de même valeur numérique. Par exemple, la commande : 0.3 setgray

génère un gris dont les composantes sont : Rouge = 0.3 ; Vert = 0.3 et Bleu = 0.3. Le zéro devant le point est habituellement omis dans les manuels et exemples anglophones. Après l’utilisation d’un gris ou d’une couleur, ne pas oublier de donner la commande 0 setgray si l’on veut retrouver un tracé de lignes en noir. 4. Dessin de surfaces et remplissage des intérieurs PostScript permet de dessiner des images colorées soit en gris, soit en couleur. Le principe de la construction des images colorées est de définir le contour de la figure et de remplir ce contour fermé par la couleur courante. L’instruction de remplissage prend la syntaxe :

fill sans opérande. Montrons par un exemple la construction de trois carrés pleins se chevauchant. Les instructions nécessaires à cette représentation sont les suivantes : newpath % Carré noir 80 x 80 250 320 moveto 0 80 rlineto 80 0 rlineto 0 –80 rlineto path close fill newpath % Carré gris foncé 80 x 80 280 360 moveto 0 80 rlineto

- 191 -


80 0 rlineto 0 –80 rlineto closepath 0.4 setgray fill newpath % Carré gris clair 80 x 80 300 400 moveto 0 80 rlineto 80 0 rlineto 0 –80 rlineto closepath etgray 0.8 s fill showpage % dessin à l’écran ou sur l’imprimante

Résultat des instructions du dessin de trois carrés superposés

Dans le cas particulier, PostScript dessine les trois carrés les uns à la suite des autres en les superposant. Le deuxième carré recouvre partiellement le premier et le troisième recouvre partielle-ment le deuxième. Les commentaires dans la programmation s’écrivent précédés du caractère %. Les trois carrés se programment par les mêmes instruction de telle sorte que l’emploi de sous-program-mes simplifierait la tâche du programmeur. PostScript comprend également ce type de structure. 7.2.1.5 SOUS-PROGRAMMES Le dictionnaire PosScript du système associe les identificateurs des procédures aux variables du programme. Le dictionnaire de l’utilisateur contient les définitions du programmeur. Ces deux diction-naires sont placés dans une pile. Le dictionnaire au sommet de la pile est le dictionnaire courant. 1. Variables PostScript Les variables PostScript sont placées, identificateur et valeur, dans le dictionnaire courant. La syn-taxe d’une variable est la suivante :

/ cnom {val} def avec : / barre oblique : point de départ de la définition d’une variable. cnom identificateur attribué à cette variable. { … } limite de la définition, optionnelle pour les nombres (nous l’utiliserons toujours). val valeur attribuée. def fin de la définition.

- 192 -


Exemple : Ce exemple montre comment définir des opérandes au moyen d’une affectation de valeur numérique à une variable. La commande scale permet de choisir ses propres unités. Affectons par programme une des valeurs proposée, par exemple la valeur 0,070866 à la variable scl : /scl {0.070866} def

scl est la variable. Utilisons cette valeur en cours de programme par l’instruction : scl scl scale

ce qui correspond à 0.070866 0.070866 scale. 2. Procédures en PostScript Une procédure correspond à un sous-programme contenant soit des variables, des opérateurs et des variables groupés dans un bloc. La syntaxe générale de cette instruction est ;

/ pnom { proced } def avec : / barre oblique : point de départ de la définition d’une procédure. pnom identificateur attribué à cette procédure. { … } limite de la définition des opérations dans la procédure. proced instructions composantes de la procédure. def fin de la définition. L’interpréteur PostScript exécute toutes les instructions entre les deux accolades lors de l’appel de la procédure. L’appel de la procédure s’effectue en écrivant son identificateur déclaré dans le corps de l’instruction d’appel. Exemple : La construction des trois carrés proposée sous 7.2.1.4 s’effectue en donnant trois fois les mêmes tracés de ligne en déplacement relatif. Ces instructions peuvent se placer dans une pro-cédure et s’appeler trois fois. Les instructions sont alors : %/Carre --- Définition de la procédure Carre ---

{ 0 80 rlineto 80 0 rlineto 0 –80 rlin te o closepath } def % --- Début du programme avec 3 appels de la procédure ---

newpath % Carré noir 80 x 80 250 320 moveto Carre 0 setgray fill newpath % Carré gris foncé 80 x 80 280 360 moveto Carre 0.4 setgray fill newpath % Carré gris clair 80 x 80 300 400 moveto Carre 0.8 setgray fill showpage

- 193 -


7.2.2 CONSTRUCTIONS GRAPHIQUES Le langage PostScript contient une collection d’instructions graphiques facilitant le dessin et une bibliothèque de fontes pour l’écriture de texte. Ce chapitre présente une collection restreinte de ces possibilités. En fin de chapitre, nous donnerons toutes les instructions d’initialisation, avec de nombreuses définitions, permettant de simplifier l’écriture manuelle et programmée des commandes. 7.2.2.1 INSTRUCTIONS POUR LES GRAPHIQUES Le langage PostScript comprend une collection d’instructions permettant de simplifier la tâche du l’utilisateur. Le tableau 7.5 présente quelques instructions supplémentaires.

Tableau 7.5 OPÉRATEURS COMPLÉMENTAIRES DE DESSIN


x1 y1 ray ang1 ang2 arc x1 y1 ray ang1 ang2 arcn x y x y ray arcto 1 1 2 2 currentpoint => x y

Ajoute au chemin courant un arc orienté dans le sens mathématique Ajoute au chemin courant un arc orienté dans le sens horaire Trace un arc tangent à deux segments Donne les coordonnées x et y du point Courant

x 1 y1 x2 y2 x3 y3 curveto

erasepage grestore gsave

Construit une courbe de Bézier qui relie les points donnés Efface la page courante (en blanc) Restitue l’état graphique sauvegardé par gsave Sauvegarde l’état graphique courant

n proc repeat ag1 rotate x1 y1 translate

Répète n fois la procédure proc Tourne le système de coordonnées de l’angle ag autour de l’origine 1

Déplace de x1 et y1 l’origine du sys- tème de coordonnées

Opérandes : x1,y1, x2,y2, x3,y3, coordonnées dans le plan ang1, ang2 angles exprimés en degrés ray rayon

1. Systèmes de coordonnées Les systèmes de coordonnées utilisés dans PostScript obéissent aux règles vues en mathé-matique. Le système de coordonnées présente primitivement l’axe O x dans la direction horizontale vers la droite, l’axe O y, perpendiculaire au premier, dans le direction verticale vers le haut. Les angles de rotation sont en degrés, le sens positif étant le sens mathématique usuel, donc dans le sens inverse des aiguilles d’une montre. Le système de coordonnées peut être modifié, soit en translation, soit en rotation. Comme déjà cité précédemment, le point O se trouve à gauche au bas de l’espace de travail. Comme les constructions graphiques doivent pouvoir se représenter à l’écran ou surtout sur une imprimante, il ne faut pas oublier que cette dernière ne peut pas imprimer sur la totalité de la feuille sans commande particulière de l’imprimante. La commande permettant de déplacer le point origine de définition vers la zone imprimable prend la syntaxe :

- 194 -


x1 y1 translate avec : x1,y1 Les deux déplacements du point origine exprimés en unité courante. Il est vivement recommandé d’utiliser cette commande avant toute construction graphique. La rotation du système de coordonnées s’effectue par la commande :

angle rotate avec : angle grandeur de l’angle de rotation en degrés, positif dans le sens mathématique. Les exemples plus complets utiliseront très souvent les instructions suivantes : 1. Feuille A4 dans le sens portrait /tranx { 50} def % Définition des variables tranx, trany, rot, scl /trany { 25} def /rot { 0.0} def /scl {0.141732} def . . . . . . . . . . . % Définitions complémentaires tranx trany translate % Intoduction dans les commandes, unités PostScript rot rotate scl scl scale

2. Feuille A4 dans le sens paysage /tranx { 550} def % Définition des variables tranx, trany, rot, scl /trany { 60} def /rot { 90.0} def /scl {0.141732} def . . . . . . . . . . . % Définitions complémentaires tranx trany translate % Intoduction dans les commandes, unités PostScript rot rotate scl scl scale

Ces instructions imposent les déplacements suivants, l’unité primitive étant 1 pouce / 72 : 1. Feuille A4 dans le sens portrait

Déplacements du point origine : Δx = 0,35278 , 50 = 17,6 mm et Δy = 0,35278 mm , 25 = 8,8 mm. L’angle de rotation rot = 0.0 et la valeur des échelles vaut scl = 0.141732 = 0,05 mm.

2. Feuille A4 dans le sens paysage Déplacement du point origine : Δx = 0,35278 , 550 = 194 mm et Δy = 0,35278 mm , 60 = 21,17 mm. L’angle de rotation rot = 90.0 et la valeur des échelles est la même que précédemment. Ainsi, la feuille est tournée de 90°, l’axe O x est parallèle au plus grand côté, l’axe O y est perpen-diculaire, parallèle au petit côté.

2. Sauvegarde de l’état graphique Il est possible de sauvegarder et de retrouver l’état graphique après l’application d’une série de commandes. Ces instructions sont très avantageuses après l’introduction d’un certain nombre de translations et de rotations du système de coordonnées. Ces deux commandes, translation et rotation, permettent parfois de simplifier la construction des figures. La syntaxe de ces deux instructions est :

gsave grestore avec : gsave Sauvegarde l’état graphique actuel en enregistrant tous les ajustements comme la

couleur, l’épaisseur des traits, le système de coordonnées, le type de fonte, etc. grestore Restitue toutes les définitions graphiques sauvegardées par la commande précédente.

- 195 -


Exemple : Le livre PostScript par l’exemple donne un programme permettant de construire une étoile à cinq branches au moyen de changements du système de coordonnées. /ContourEtoile { 72 0 lineto currentpoint translate -144 rotate } def /Etoile { moveto currentpoint translate 4 { ContourEtoile } repeat closepath gsave .5 setgray fill grestore stroke } def 200 200 Etoile showpage

La commande currentpoint translate effectue les opérations suivantes : currentpoint enregistre les coordonnées du point actuel sur la pile et translate utilise ces deux valeurs pour effectuer le déplacement. Le programme principal ne contient que les deux dernières lignes. L’instruction 200 200 Etoile empile 200 fois les coordonnées x , y et appelle ensuite la procédure Etoile.

Nous n’utiliserons pas systématiquement ces deux instructions de sauvegarde dans les program-mes en FORTRAN. 3. Construction des arcs de cercle Plusieurs commandes PostScript permettent de tracer des arcs de cercle dans le plan du dessin. La mesure des angles exprimés en degrés s’effectue à partir de l’axe O x .La syntaxe de la com-mande de base est :

x1 y1 ray ang1 ang2 arc avec : x1 y1 coordonnées du centre de courbure de l’arc. ray rayon de courbure de l’arc. ang1 ang2 ang1 angle de départ en degrés de l’arc de cercle,

ang2 angle de fin de l’arc de cercle en degrés, le sens de rotation étant le sens mathé-matique.

La commande suivante effectue les mêmes opérations, mais le sens de la construction est le sens horaire. La syntaxe est

x1 y1 ray ang1 ang2 arcn Les opérandes ont même signification que précédemment, seule différence le sens de rotation de la construction. Exemples : 1. Cercle complet de rayon 100, centre à x = 125, y = 200 : 125 200 100 0 360 arc

2. Arc de cercle de rayon 75, centre à x = 210, y = 140, entre 60° et 180°. 210 140 75 60 180 arc % Sens mathématique 210 140 75 180 60 arcn % Sens horaire 3. Construction d’une ellipse :

Pour dessiner une ellipse à partir de la commande de l’arc de cercle, il est nécessaire de modifier l’échelle du dessin selon l’axe de la compression de la courbe. Soit à dessiner une ellipse dont l’axe vertical vaut 60 % de l’axe horizontal. Les coordonnées du centre se trouvent à x = 160 et y = 225, le rayon du cercle étant 100.

- 196 -


1 1 scale % Même unité sur les deux axes gstore % Sauvegarde des définitions graphiques 1 0.60 scale % Unité sur Oy à 60% de Ox 160 225 100 0 360 arc stroke grestore % Restauration => 1 1 scale

La dernière des commandes d’arcs permet d’arrondir les angles entre deux lignes dont les coor-données sont connues. La syntaxe de l’instruction est :

x1 y1 x2 y2 ray arcto avec : x1 y1 Coordonnées x1, y1 définissant la position du point terminal du premier segment recti-

igne, ce segment partant des coordonnées connues placées sur la pile. x2 y2 Coordonnées x2, y2, définissant le point terminal du deuxième segment rectiligne, ce

segment partant du point placé sur la pile, soit x1 et y1. ray rayon du raccordement entre les deux segments. 7.2.2.2 INSTRUCTIONS POUR LES TEXTES La plupart des représentations graphiques contiennent du texte et PostScript comprend des com-mandes dans ce but. Une fonte de caractères définit le dessin de la lettre et la famille de caractères comprend toutes les variantes de cette fonte comme le texte normal, étendu ou condensé, le texte en gras, le texte droit ou italique. Les fontes sont définies dans le dictionnaire de fontes. 1. Utilisation des fontes L’utilisateur des fontes doit définir la fonte désirée pour le texte. Cette opération consiste à choisir dans la collection la fonte désirée, dépendant également de l’implémentation du langage, de l’échelle souhaitée en unités courantes, et finalement donner les instructions nécessaires d’écriture.

Tableau 7.6 CHOIX DE QUELQUES FONTES POSTSCRIPT

Times Helvetica Courier

Times-Roman Times-Bolt Times-Italic Times-BoltItalic

Helvetica Helvetica-Bolt Helvetica-Oblique Helvetica-BoldOblique

Courier Courier-Bolt Courier-Oblique Courier-BoltOblique

Lettres grecques droite : Fonte = Symbol Σψμβολ

Les commandes nécessaires à l’utilisation d’une fonte déterminée consiste à trouver la police désirée dans le dictionnaire, à déterminer sa taille et à la rendre accessible. Les syntaxes de ces trois commandes sont les suivantes. 1. Trouver la police

/ police findfont avec : / début de l’instruction police identificateur de la police selon tableau 7.6. 2. Définir la taille de la police

taille scalefont avec : taille taille désirée en unité courante.

- 197 -


3. Sélectionner la police et la rendre active

setfont avec : - Commande sans paramètre. La police devient la fonte courante. 4. Instruction d’écriture du texte

{ texte } show avec : { } limiteurs du texte à écrire texte texte à écrire dans la police et la taille choisies. Exemple : /Times-Roman findfont 14 scalefont setfont 5{Ecole technique} show 0 100 moveto

showpage

Résultat des instructions :

Ecole technique Remarque pour les utilisateurs de Win-Word Les fontes de PostScript portent les noms des identificateurs originaux et sont protégés. La dessin de ces fontes est supérieur à celles employées dans Word. La fonte Helvetica, crée par la société suisse Caractères SA La Chaux-de-Fonds, a été remplacée par Arial par Microsoft. Le code des caractères ne contient pas les lettres accentuées ! 2. Position du texte sur la feuille La commande moveto permet de positionner le pointeur et fixer le début de l’écriture d’un texte. Dans les applications mathématiques et techniques, il arrive assez fréquemment de devoir écrire un titre ou un sous-titre dans une position bien déterminée, par exemple un titre en dessus d’un graphique en position centrée. Les dimensions du texte à écrire, en unités courantes, peut se trouver au moyen de l’instruction stringwidth dont la syntaxe est :

stringwidth - l1 l2 La commande stringwidth retire la chaîne de caractères du sommet de la pile et la remplace par la dimension longueur du texte l1 et la hauteur du texte l2. La hauteur l2 se trouve alors au sommet de la pile, la longueur l1 immédiatement en dessous. En termes pratiques, cela revient à donner l’ins-truction : dup stringwidth pop

pour mettre la longueur l1 sur la pile, la chaîne de caractères se trouvant immédiatement en dessous. Pour obtenir un texte centré, il suffit de déplacer le début du texte de la moitié de sa longueur à partir du point milieu. L’utilisation de la police Courier facilite cette opération car la largeur de tous les caractères majus-cules ou minuscules est constante. Connaissant la largeur d’un caractère, le déplacement du point central au point situé au début de la chaîne se programme facilement, sans passer par l’instruction stringwidth. 3. Modification des tailles des caractères La taille et le type de caractère se définit dans l’instruction : /police findfont

avec police l’identificateur de la police à utiliser. La taille se donne dans la commande : taille scalefont

- 198 -


avec taille la grandeur des caractères. L’opérateur scale permet de modifier soit la hauteur, soit la largeur des caractères en supposant que l’une des dimensions soit 1, l’autre différent de 1. Il existe une commande qui permet de modifier la taille et l’inclinaison des caractères. La syntaxe de cette instruction est :

[ m 0 p n 0 0 ] makefont avec : [ … ] délimiteur de la matrice de transformation courante des caractères m taille de la fonte dans la direction horizontale. p pente de l’écriture, si l’écriture est verticale, alors p = 0. Calcul de la pente : valeur = taille x tangente(angle) n taille nominale de la fonte comme dans l’instruction scalefont. Exemples /Times-Roman findfont 12 scalefont /Times-Roman findfont [12 0 0 12 0 0] makefont Ces deux instructions sont identiques /Times-Roman findfont [15 0 0 12 0 0] makefont La largeur des cartères est augmentée de 25%. /Times-Roman findfont [9 0 0 12 0 0] makefont La largeur des caractères est diminuée de 25 %. /Times-Roman findfont [12 0 6.93 12 0 0] makefont L’écriture est inclinée de 30° car 6,93 = 12 x tan(30°) . 7.2.2.3 INSTRUCTIONS POUR LA PROGRAMMATION FORTRAN Le premier exemple de programmation donne les instructions nécessaires pour les définitions et simplifications d’écriture. Les instructions proposées sont utilisées dans les exemples de listing de dessins obtenus par programmation. Il s’agit pour la plupart de dessins composés de traits. Les commandes sont reprises du logiciel pour calculs en éléments finis ANSYS de la maison Swanson & Co, version 5.0. Le choix des fontes est limité à la fonte Courier et le facteur de multiplication de la commande scale est 0,070866 ou son double, soit un pas de 0,025 mm. Trois dimensions de caractères sont programmées; Courier 60, T00, hauteur 1,5 mm Courier 80, TO, hauteur 2 mm Courrier 120, T1, hauteur 3 mm. 1. Commandes dans la partie du prologue de tout fichier Postscript %!PS-Adobe-2.0 EPSF-2.0 %%BoundingBox: 0 0 590 840 %%DocumentFonts: Courier /tranx { 50} def /trany { 25} def /rot { 0.0} def /scl {0.070866} def /M {moveto} def /L {lineto} def /RL (rlineto) def /S {stroke} def /SW {setlinewidth} def /CP {closepath} def /N {newpath} def /G {setgray} def /R {setrgbcolor} def /F {fill} def

- 199 -


/SN {stroke newpath} def /FE {gsave fill grestore} def /T00 {/Courier findfont 60 scalefont setfont} def /T0 {/Courier-Bold findfont 80 scalefont setfont} def /T1 {/Courier-Bold findfont 120 scalefont setfont} def /L0 {[] 0 setdash} def /L1 {[10 5] 0 setdash} def /R00 {1.000 1.000 1.000 setrgbcolor} def /R01 {1.000 0.000 0.500 setrgbcolor} def /R02 {1.000 0.000 1.000 setrgbcolor} def /R03 {0.500 0.000 1.000 setrgbcolor} def /R04 {0.000 0.000 1.000 setrgbcolor} def /R05 {0.000 0.500 1.000 setrgbcolor} def /R06 {0.000 1.000 1.000 setrgbcolor} def /R07 {0.000 1.000 0.500 setrgbcolor} def /R08 {0.000 1.000 0.000 setrgbcolor} def /R09 {0.500 1.000 0.000 setrgbcolor} def /R10 {0.700 0.700 0.000 setrgbcolor} def /R11 {1.000 0.500 0.000 setrgbcolor} def /R12 {1.000 0.000 0.000 setrgbcolor} def /R13 {0.600 0.600 0.600 setrgbcolor} def /R14 {0.300 0.300 0.300 setrgbcolor} def /R15 {0.000 0.000 0.000 setrgbcolor} def /ER {R00 clippath F SN R15} def /byte 1 string def /byt3 3 string def /unpack_colr 765 string def /color_decode { currentfile byte readhexstring pop 0 get /npix exch 3 mul def currentfile byt3 readhexstring pop pop /color_packet byt3 0 3 getinterval def 0 3 npix 1 sub { unpack_colr exch color_packet putinterval } for unpack_colr 0 npix getinterval } bind def /setup {save /Courier findfont 60 scalefont setfont} def

- 200 -


%%EndProlog (fin du prologue, pourrait se trouver dans un fichier texte) %%Page: 1 1 (début de la mise en action du dessin) setup tranx trany translate rot rotate scl scl scale ER . . . . . . . . . . . . . Ces diverses commandes d’initialisation comprennent la définition de 16 couleurs dont le symbole d’identification va de /R00 à /R15. La figure suivante montre les commandes et les couleurs définies.

Définition des couleurs selon logiciel Ansys 2. Partie de la fin des commandes La partie terminale contient seulement 4 instructions, S pour stroke et showpage pour la trans-mission de la figure vers l’écran ou le périphérique, retour aux commandes par défaut, fin. S showpage restore %%Trailer

- 201 -


3. Construction de la partie graphique Dans la partie intermédiaire, les instructions se composent essentiellement de newpath, moveto, lineto, stroke, le choix d’une des fontes, son appel et son utilisation. Les opérandes des commandes moveto et de lineto sont calculés le plus souvent par le programme écrit en langage FORTRAN (ou en PASCAL). L’identificateur SN donne les deux commandes stroke newpath.

En supplément, donnons encore un exemple de programmation ANSYS, version 5.6, permettant de dessiner une surface quadrilatérale au moyen d’une seule commande :

Définitions : /C {closepath} def /L {lineto} def /M {moveto} def /FE {gsave fill grestore} def /s stroke newpath} def /v {M L L L C FE} def

Commandes : 0.000 1.000 1.000 R % Choix de la couleur 848 821 945 859 819 992 741 865 v R15 % Couleur noir s La matrice d’identificateur /v définit les déplacements moveto, 3 fois lineto, closepath, le remplissage de la surface par le vert R06 (0.000,1.000,1.000) avec sécurités sur le système de coordonnées par gsave et grestore encadrant la commande fill. Finalement, la couleur noire est appelée comme couleur par défaut, identificateur R15. Le quadrilatère est donc entièrement construit et coloré au moyen de 4 instructions. 7.2.2.4 EXEMPLE D’UTILISATION DU LANGAGE POSTSCRIPT Le langage Postscript a été utilisé pour résoudre un problème classique en mathématique numé-rique, soit à calculer et représenter la valeur de la fonction y = f(x) entre deux limites xmin et xmax, de trouver la valeur numérique de la fonction dérivée et la valeur de l’intégrale entre ces deux limites. Ces trois fonctions sont à représenter graphiquement. Fonction à représenter : y x x= = ⋅ ⋅ ⋅ ⋅ ⋅f e-0.04 x( ) sin( . ) .8 05 π Domaine de l'investigation : Borne inférieure de calcul : 0.000 Borne supérieure de calcul : 8.000 Nombre d'intervalles 40 Nombre de points définis : 41 ÉVALUATION DES DEUX DÉRIVÉES AUX POINTS DE DÉFINITION No Abscisse x(i) Ordonnée y(i) Dérivée y' Dérivée y" 0 0.00000 0.000000 12.566371 -1.005310 1 0.20000 2.452438 11.758002 -6.995712 2 0.40000 4.627644 9.819933 -12.211253 3 0.60000 6.318654 6.958420 -16.157437 .. .. .. .. .. etc. RECHERCHE DE LA SOMME INTÉGRALE DE LA FONCTION DISCRÈTE No Abscisse x(i) Fonction y(i) Delta Int. Intégrale 0 0.00000 0.00000 0.00000 0.00000 1 0.20000 2.45244 0.24795 0.24795 2 0.40000 4.62764 0.71448 0.96243 3 0.60000 6.31865 1.10419 2.06662

- 202 -


4 0.80000 7.36884 1.38041 3.44703 5 1.00000 7.68632 1.51812 4.96515 6 1.20000 7.25187 1.50612 6.47127 7 1.40000 6.11966 1.34797 7.81924 8 1.60000 4.41076 1.06134 8.88058 .. .. .. .. etc. Pour le dessin des courbes, chaque tracé des trois courbes comporte 200 points de définition dé-composé en groupes de 3 fois 60 points et une fois 20 points. Cette décomposition est nécessaire car la pile de Postscript est limitée ! Le fichier Postscript occupe 12 229 octets ! La figure ci-dessous montre le résultat du calcul

Sur ce graphique, la fonction, sa dérivée et son intégration sont représentés à l’échelle 1 à 1, va-leur donnée par le facteur de multiplication placé après le texte correspondant. 7.3 IMPLÉMENTATION EN FORTRAN Dans ce sous-chapitre, nous voulons présenter les particularités de chacune des implémentations du langage FORTRAN. Chaque constructeur de compilateur étend les possibilités de programmation afin de faciliter la tâche des utilisateurs. Remarquons que les instructions de base sont portables sur tous les systèmes et que les adjonctions rendent difficilement transportables les programmes écrits au moyen d'instructions spécifiques à une implémentation.

- 203 -


7.3.1 IMPLÉMENTATION : DOMAIN FORTRAN La documentation concernant cette implémentation du langage se trouve dans le manuel de la fir-me APOLLO Computer Inc. , 330 Billerica Road, Chelmsford, MA 01824, USA : DOMAIN FORTRAN Language Reference Order No. 000530 Revision 005 Le système d'exploitation des stations APOLLO est : AEGIS . 7.3.1.1 PARTICULARITÉS Les particularités de l'implémentation sont écrites en rouge dans le manuel de référence du lan-gage. Nous donnons ci-après la plupart de ces particularités. 1. Identificateurs Les caractères admissibles sont : toutes les lettres majuscules et minuscules, les chiffres de 0 à 9, le caractères de soulignement _ et le caractère dollard $ . Le nombre maximal de caractères est limité à 32. 2. Écriture des instructions Les commentaires sont signalés par les caractères C, c et * placés dans la première colonne. Ils peuvent également se donner sur la même ligne que l'instruction ou sur une autre ligne encadrés par les accolades 1 ... 1. La première colonne peut contenir le caractère D ou d indiquant une compilation conditionnelle. Comme les instructions se terminent à la colonne 72, le compilateur ignore les com-mentaires à partir de la 73ième colonne, même ceux dépassant la 80ième. 3. Types de données Les types de données à disposition sont : - entiers : integer, integer*2, integer*4 - réels : real, real*4, double precision, real*8 - booléens : logical - complexes : complex - caractère : character*lën - tableaux : de types simples, jusqu'à 7 dimensions - pointeurs admet une instruction pointer rendant l'interfçage possible. 4. Instructions Le compilateur comprend quelques instructions hors norme ANSI : - do while boucle tant que - namelist définit un synonyme pour une liste de variables ou de tableaux - decode transfert de données de la mémoire vers la liste d'E/S - encode mise en forme des données et transfert vers la mémoire - end do termine une boucle do ... ou do while Les sous-programmes subroutine et function peuvent être récursifs, c'est-à-dire s'appeler eux-mêmes, soit directement, soit indirectement. Le descripteur d'édition $ empêche le retour à la ligne dans l'instruction write Les descripteurs a et Z peuvent s'utiliser pour tout type de variable. Le compilateur admet, dans la clause status les extensions suivantes : 'append' , 'write' , 'readonly' , 'overwrite' . Pour arrêter le déroulement d'un programme complètement, par exemple lorsqu'il effectue une boucle sans issue de sortie, frappez : Ctrl-Q.

- 204 -


5. Fonctions "intrinsic" Les fonctions fondamentales du langage sont présentes, complétées par des fonctions pour la manipulation de type et de bits. Ces fonctions particulières sont les suivantes : Fonctions de conversion de type : int2 convertit en type integer*2 int4 convertit en type integer*4 Fonctions de manipulations de bits : and , or , xor , not , rshft , Ishft , iaddr retourne l'adresse de l'argument qui peut être de tout type (y compris les tableaux et

les identificateurs de sous-programmes) , le résultat étant de type integer*4 . 7.3.1.2 DIRECTIVES DE COMPILATION Le compilateur admet un certain nombre de directives de compilation qui doivent se programmer à partir de la colonne 1 , à part %config et toutes doivent commencer par le caractère % à part debug. Exemple : %nolist %include '//dn3002/meca2/etudiant/work/programl.ftn' %include '//dn3002/meca3/etudiant/work/program2.ftnl %list ...

Ces directives permettent d'éviter de créer le fichier .Ist pour les deux codes situés entre %nolist et %list.

Tableau 7.7 DIRECTIVES DE COMPILATION POUR DOMAIN FORTRAN

Directives Significations

%config debug %eject %else %elseif pred

%then

Introduit un message de mise en garde si la compilation n'est pas effectuée avec l'option -config debug Indique que les lignes débutant par D ou d et l'option -cond sont à compiler Introduit une remise à la page dans le listing en ce point Spécifie qu'un bloc de code doit être compilé s'il est précédé de %if pred %then losque pred est faux Exécute la compilation du code jusqu'au prochain %else, %elseif ou %endif si pred est vrai

%elseifdef pred %then %enable %endif %error 'str' %exit

Contrôle si un pred additionnel a été déclaré avec une directive %var Affecte la valeur vraie aux variables de compilation Fin du bloc de compilation conditionnelle Imprime 'str' comme message d'erreur Indique au compilateur d'arrêter le processus conditionnel du fichier

%if pred %then %include 'nomfich' %list %nolist %var %warning 'str'

Exécute la compilation du code jusqu'au prochain %else, %elseif ou %endif si pred est vrai Indique au compilateur de lire en entrée le fichier nommé nomfich Introduit le code dans le fichier .lst Désaffecte la création de la liste du fichier Déclare des variables que l'on peut utiliser pour pred dans les directives de compilation Imprime 'str' comme message de mise en garde pendant la compilation

- 205 -


7.3.1.3 DÉVELOPPEMENT DE PROGRAMME Le développement de programme comprend toujours les trois opérations : édition du fichier d'instructions dit fichier source, compilation de ce fichier en langage machine et l'assemblage ou liaison avec le système d'exploitation. L'environnement du réseau DOMAIN facilite ces diverses tâches. 1. Edition du fichier source L'édition du fichier source s'effectue comme l'édition de tout fichier de texte. En ouvrant la fenêtre à l'écran au moyen de la touche <EDIT> suivie du nom du fichier et de l'extension .ftn , l'écriture peut s'effectuer en plaçant 6 espaces blancs avant toute instruction. Le fichier est enregistré en pressant sur la touche <EXIT> . 2. Compilation La compilation est obtenue simplement par la commande : $ ftn nomfich –1 Dans cette commande, nomfich est le nom du fichier contenant le code source du programme, la directive de compilation -1 indiquant au compilateur de créer un fichier : nomfich.lst contenant toutes les instructions numérotées et les bilans de la compilation. Si la compilation s'effectue correctement, cette commande engendre deux fichiers : - fichier liste des instructions, avec l'extension .Ist , avec le bilan de la compilation - fichier en langage machine, extension .bin Voici quelques options complémentaires : -dba génère un code non optimisé pour le débogueur -dbs génère un code optimisé pour le débogueur -i*2 introduit integer*2 par défaut pour le type integer -i*4 introduit integer*4 par défaut pour le type integer (c'est l'option par défaut) -l engendre un fichier liste de la compilation -save réserve de la place pour les variables locales -type introduit un message de mise en garde pour les variables non déclarées -zero initialise à zéro tous les blocs communs et les variables statiques 3. Editeur de lien L'éditeur de lien, servant à rendre le programme exécutable à partir du programme traduit en lan-gage machine, est appelé par la commande : $ bind nomfichl.bin [nomfich2 ...] -b nomexecut Les fichiers en langage machine sont cités les uns à la suite des autres, nomexecut étant le nom du fichier exécutable. Il n'est pas absolument nécessaire de donner une extension à ce nom car le genre de fichier apparaît lors de l'affichage de la liste des fichiers : Id -a . 4. Recherche des erreurs Les erreurs de compilation sont données dans le fichier liste. Si pendant l'exécution du program-me, une erreur d'exécution intervient, cette erreur peut se repérer par la commande : $ tb L'écran affiche alors un message détaillé des divers modules d'accès au programme et de la ligne sur laquelle une erreur est intervenue. 5. Autres facilités du logiciel Les possibilités complémentaires offertes par le logiciel sont : 5.1 Appel de divers auxiliaires facilitant le développement des programmes - DSEE : DOMAIN Software Engineering Environnment - DOMAIN / Dialogue - création de sa propre bibliothèque de programme

- 206 -


5.2 DOMAIN FORTRAN peut utiliser des parties de programme écrites dans un autre langage de programmation : - langage C , - langage Pascal 5.3 Graphique : Comme les stations APOLLO sont dédicacées surtout aux représentations graphiques, le program-meur a la possibilité d'accéder aux ressources des librairies graphiques 2D ou 3D du système. Nous voulons présenter ici un programme, écrit en FORTRAN, permettant de tracer des cercles à l'écran. * • Exemple 40 • Dessin de cercles concentriques sur station APOLLO • Librairie : GPR * program. exem40 %include '/sys/ins/bas.ins.ftn' %include '/sys/ins/gpr.ins.ftn' %include '/sys/ins/time.ins.ftn' integer*2 size(2) * * description de la memoire d'ecran * integer*4 init_bitmap integer*2 mode * integer*2 hi_plane_id integer*2 center(2) integer*2 radius,i logical delete_display * integer*4 status integer*2 pause (3) * center(1) = 350 center(2) = 350 size(1) = 700 size(2) = 700 mode = gpr_$borrow hi_plane_id = 1 * call gpr_$init(mode,int2(1),size,hi_plane–id, + init–bitmap,status) do i = 1,10 radius = i*35 call gpr_$circle (center,radius,status) pause(1) = 0 pause(2) = 5 pause(3) = 0 call time_$wait (time_$relative,pause,status) end do * call gpr_$terminate (delete_display, status) end

- 207 -


7.3.2 IMPLÉMENTATION : MS-FORTRAN La plupart des exemples de programme en FORTRAN 77 cités dans ce document ont été testés sur un micro ordinateur dans les années 1988 à 1992. La collection d’exercices, annexée à ce document, date aussi de cette époque. Ce cours a été transmis aux étudiants pendant 16 semaines à raison de 2 heures par semaine, le semestre précédent, à raison de 2 heures par semaine, était con-sacré à l’utilisation du langage Pascal. A cette époque, la plupart des logiciels tournaient sur le système d’exploitation DOS. Un avantage essentiel pour ce système d’exploitation (et pour la programmation) était que toutes les instructions servaient à la solution du problème et non à la mise en forme, cette dernière se résumait à deux ou trois lignes d’instruction : effacer l’écran et presser sur une touche. Le listing volumineux « Palier » est un exemple d’un programme complet pour le calcul des paliers radiaux en régime hydrodynamique (développé sur Vax 11-70 de l’Université de Fribourg). Selon réclame Microsoft, seuls les meilleurs compilateurs sont certifiés sans erreur par le GSA (Administration américaine des services généraux). Le compilateur optimiseur Microsoft FORTRAN a rejoint ce groupe d'élite. C'est une adaptation complète du standard ANSI, ce qui veut dire qu'un même programme peut être porté sur PC et gros système. Il utilise la technique du compilateur C, qui vise à une amélioration automatique du code généré. Il en résulte un programme plus compact et rapide. Plusieurs bibliothèques mathématiques sont mises à la disposition du programmeur d'appli-cations industrielles ou scientifiques. Chaque message d'erreur est expliqué en détail tandis que le manuel fournit différent moyens de résoudre le problème. Le compilateur permet de créer des programmes allant de 1 Mo de code sous MS-DOS, jusqu'à 16 Mo de code sous MS OS/2, et des tableaux de plus de 64 Ko. Trois modèles mémoire sont disponibles selon les besoins du développeur. Microsoft FORTRAN version 5.0 supporte les copro-cesseurs 8087 , 80287, 80387, et intègre le logiciel de développement CodeView. Cette version du langage est entièrement compatible avec SAA (Systems Application Architecture) et contient plusieurs extensions VAX. De plus, une septentaine de routines graphiques sont à disposition pour la gestion de texte et de dessins à l'écran dans l'environnement DOS. La documentation concernant cette implémentation du langage FORTRAN se trouve dans les ma-nuels de la firme Microsoft Corporation, 16011 NE 36th Way, Box 97017, Redmond, WA 98073-9717 : Microsoft FORTRAN Reference (contient la syntaxe du langage et les commandes) Advanced Topics (contient l'environnement et la librairie graphique) Documents LN0818-500-R00-0289 : parts 06383 & 06384 (1989) Version discutée ici : 5.0 , l'ancienne version 3.31 était un sous-ensemble du langage FORTRAN selon norme ANSI . Dans cette partie, nous présenterons les caractéristiques principales de cette implémentation. 7.3.2.1 PARTICULARITÉS Les particularités de l'implémentation sont écrites en bleu dans le manuel de référence du lan-gage. Nous donnons ci-après la plupart de ces particularités. 1. Identificateurs Les caractères admissibles sont les 52 lettres majuscules et minuscules, le caractère $ , les chif-fres 0 à 9 , l'espace, le caractère tab et une collection d'autres caractères spéciaux. Le nombre de caractères significatifs des identificateurs est limité à 31, ce nombre pouvant être limité à la valeur normée de 6 caractères par une directive de compilation. Les identificateurs suivants sont prédéfinis et ne peuvent pas s'utiliser dans le programme : 1. _main nom externe pour le programme principal quel que soit l'identificateur programmé dans

l'instruction program 2. COMMQQ nom pour les blocs de commun blanc. 3. BLKDQQ nom par défaut pour le sous-programme block data

- 208 -


2. Ecriture des instructions La position des caractères suit les règles énoncées dans le cours sous. Un C (c) ou * dans la colonne 1 indique un commentaire; un $ dans la même colonne indique une directive de compilation. L'emploi du tabulateur permet d'atteindre la colonne correspondant à la colonne 7 (solution non recommandée, car non portable). Dans les chaînes de caractères, les lignes plus courtes que 72 sont complétées par des blancs, d'où attention aux chaînes de caractères programmées sur plusieurs lignes. Le nombre de lignes de suite est limité à 19. Il existe une option de programmation des instruc-tions dite en forme libre. Il est possible de placer des commentaires sur la ligne d'instruction en les faisant précéder du point d'exclamation ! . 3. Types de données Les types de données à disposition sont : 1. entiers : integer, integer*1, integer*2, integer*4 integer*1 : domaine -128 à + 127 2. réels : real, real*4, double precision, real*8 3. complexes : complex, complex*8, double complex, complex*16 4. booléens : logical, logical*1, logical*2, logical*4 logical*1 contient 0 si .false. , 1 si .true. logical*2 contient logical*1 dans le premier octet logical*4 contient logical*2 dans les deux premiers octets 5. caractères : character*n avec 1 <= n <= 32 767 C strings : valeur pour langage C 6. tableaux : de type simple, le nombre de dimensions n'étant pas limité les indices peuvent être des expressions arithmétiques converties en entier. 7. Enregistrements dont les variables sont définies dans le type : structure 4. Instructions Les instructions selon norme ANSI sont applicables dans la programmation. Les instructions propres à cette implémentation sont : - allocate établit dynamiquement les dimensions d'un tableau - automatic éclare une variable à placer sur la pile - cycle passe à l'instruction terminale d'une boucle do - deallocate libère la place mémoire allouée précédemment par allocate - do while ... end do et do ... end do , hors norme ANSI, sont applicables dans la dernière version. - interface déclare un sous-programme, ses attributs et ses paramètres formels - include insère un fichier source en ce point - locking verrouille l'accès direct au fichier ou à l’enregistrement pour d'autres utilisateurs - map ... end map , délimite ou groupe de déclarations de types de variables - namelist définit une liste de variables simples et de tableaux associées à une liste - select case ... end select : définit une structure de sélection - structure ... end structure : définit un nouveau type de variable, composé d'une collection d'autres types de variables. Le langage possède encore des attributs, hors norme, utilisés dans plusieurs instructions fonda-mentales. Ce sont : - allocatable attribue une dimension dynamique pour un tableau, - alias attribue un nom externe à un sous-programme ou à un bloc common - C attribue les conventions d'appel du langage C - extern indique qu'une variable est placée dans une autre unité, dans un autre langage - far argument à passer par adresse du segment - huge spécifie qu'un paramètre formel se trouve dans plus d'un segment - loadds spécifie un autre segment de données pour sous-programmes compilés - near indique que le paramètre effectif se trouve dans le segment des données - pascal identifie un argument ou sous-programme ayant les caractéristiques selon Pascal

Microsoft - reference indique un passage de paramètre formel par adresse plutôt que par valeur - value indique un passage par valeur d'un paramètre formel - varying permet d'obtenir un nombre différent de paramètres formel et effectifs entre

- 209 -


FORTRAN et C (le langage C permet cette option). Le descripteur \ ou $ empêche le retour à la ligne dans l'instruction write (...) . Le descripteur Z est applicable aux données entières en hexadécimal. Dans les fichiers, les clauses complémentaires applicables sont : - blocksize spécifie ou détermine la taille de la mémoire tampon en E/S - mode contrôle l'accès aux processus ou au réseau, les options étant : 'readwrite', 'read' ou 'write' - share contrôle l'accès simultané aux processus, les options étant : 'compat', 'denynone', 'denywr', 'denyrd', 'denyrw' Si une instruction open est exécutée sous un nom constitué par des blancs, le nom du fichier peut se donner au clavier. Si read ou write sont employés avant l'ouverture du fichier, le nom du fichier doit s'entrer au clavier. Les unités pré-connectées sont : * le clavier et l'écran 0 représente initialement le clavier et l'écran 5 représente initialement le clavier 6 représente initialement l'écran A part les fichiers codés et non formatés, le langage peut traiter les fichiers en octets, sans struc-ture interne, au moyen de la forme : form='binary'. 5. Fonctions "intrinsic" Les fonctions fondamentales du langage sont présentes, complétées par les fonctions pour les types : type*1 et complex*16. Les fonctions supplémentaires sont citées comme suit : Fonctions de conversion de type : dcmplx , dreal , int1 , int2 , int4 , intC , hfix , jfix Fonctions d'information sur les types : allocated , epsilon , huge , maxexponent , minexponent , nearest , precision , tiny Fonction absolue pour complex*16 : cdabs(cmpl16) , résultat : fonction de type real*8 Fonctions d'opérateurs complexes : imag(cmp) , dimag(cmpl16) , dconjg(cmpl16) Fonctions mathématiques : cdsqrt(cmpl16) , cdexp(cmpl16) , cdlog(cmpl16) Fonctions trigonométriques : cdsin(cmpl16) , cdcos(cmpl16) , cotan(real) , dcotan(dbl) Fonctions sur les caractères : len_trim(char) , scan(char,charset) , verify(char,charset) Fonction fin de fichier : eof(int) résultat de type logical permet de détecter la fin de fichier. Fonctions d'adresse : locnear , locfar , loc Fonctions de manipulation de bits : btest , ior , ishl , ishft , isha , ishc , ieor , iand , not , ibclr , ibset , ibchng Subroutines et fonctions d'accès à l'horloge du micro-processeur : gettime(ihr,imin,isec,i100th) reçoit le temps du système subroutine getdat(iyr,imon,iday) reçoit la date du système subroutine settime(ihr,imin,isec,i100th) introduit le temps dans le système function setdat(iyr,imon,iday) introduit la date dans le système function Les deux fonctions sont de type logical, tous les arguments étant de type integer*2 soit : ihr heure (0..23) iyr année (xxxx a.J.C) imin minute (0..59) imon mois (1..12) isec seconde (0..59) iday jour (1..31) i100th centième de seconde (0..99) Générateur de nombres pseudo-aléatoires

- 210 -


La subroutine random retourne une valeur réelle pseudo-aléatoire comprises entre 0 et 1 . La rou-tine seed change le point de départ du générateur : call random (ranval) call seed (seedval) avec : ranval valeur retournée de type integer*4 seedval argument de type integer*2 pour initialiser le générateur 7.3.2.2 DIRECTIVES DE COMPILATION Les directives de compilation, désignées par Metacommand dans le manuel, servent à modifier les conditions par défaut de compilation. Elles sont données par ordre alphabétique. $DEBUG et $NODEBUG par défaut : $NODEBUG . $DEBUG introduit des tests additionnels : dépassement en arithmétique des entiers, contrôle du goto assigné, retient les lignes de compilation, contrôle les sous-chaînes, le domaine des entiers. $DECLARE et $NODECLARE par défaut : $NODECLARE . $DECLARE génère des messages de mise en garde pour les variables non déclarées. $DEFINE symbol_name Crée et optionnellement assigne une valeur à une variable dont la présence peut être testée pendant une compilation conditionnelle. $DO66 Cette directive introduit le traitement de la boucle do ... selon FORTRAN IV , la boucle étant parcou-rue au moins une fois. $ELSE Marque le début d'un bloc de compilation conditionnelle si la condition logique du $IF correspondant est .false. $ELSEIF expr Marque le début d'un nouveau bloc de compilation conditionnelle dans le contexte d'une condition logique $IF . $ENDIF Termine une structure comportant $IF , $IF ... $ELSE ou $IF ... $ELSEIF $FLOATCALLS et $NOFLOATCALLS par défaut : $NOFLOATCALLS . $FLOATCALLS appelle la librairie du langage pour les opérations en virgule flottante, $NOFLOATCALLS impose un traitement par le coprocesseur. Il est recommandé de ne plus employer ce genre de commande, mais de donner cette possibilité lors de l'édition de lien. $FREEFORM et $NOFREEFORM par défaut : $NOFREEFORM , cette directive indiquant un traitement des lignes d'instruction selon les règles fondamentales. $IF expr Marque le début d'un bloc de compilation conditionnelle . Les instructions suivantes sont compilées si l'expression est .true. $INCLUDE ' nomfich ' Cette directive impose un traitement de 'nomfich' par le compilateur, à partir de la ligne contenant cette directive. $LARGE :name et $NOTLARGE par défaut : $NOTLARGE . $LARGE indique qu'un tableau est stocké à l'extérieur du segment DGROUP. La directive est accompagnée des noms de tableaux, séparés par la virgule. Les tableaux avec dimensions explicites plus grand que 64 Ko sont placés automatiquement dans plusieurs segments et ne doivent pas apparaître dans $LARGE. $LINESIZE:n Impose n colonnes par page dans la compilation (40..132) , par défaut 80. $LIST et $NOLIST

- 211 -


par défaut : $LIST . Indique si une liste ou non de compilation doit être engendrée lorsque une option est introduite dans la ligne d'appel du compilateur. $LIST Commence la génération d'informations à envoyer au fichier de listing. $NOLIST supprime cette génération. $LOOPOPT Optimise le code des boucles itératives et $NOLOOPOPT supprime cette particularité. $MESSAGE:string Envoie un message à l'écran lors de la première passe de compilation. $PACK:n Introduit le nombre d'octets pour la définition de début de stockage (1 , 2 ou 4) $PAGE Commence une nouvelle page dans la liste de compilation. $PAGESIZE:n Introduit n lignes par page de compilation : n >=15 , par défaut 63. $STORAGE:n Définit le nombre d'octets, 2 ou 4, pour toutes les variables du fichier source de types integer et logical, la valeur par défaut étant 4 . $STRICT et $NOTSTRICT par défaut : $NOTSTRICT . $STRICT n'accepte que la syntaxe de FORTRAN 77 selon la norme ANSI sans les extensions ou implémentations particulières. $SUBTITLE:subtitle Introduit un sous-titre dans la liste de compilation. $TITLE:title Introduit un titre dans la liste de compilation. $TRUNCATE et $NOTRUNCATE par défaut : $NOTRUNCATE permet de rendre jusqu'à 31 caractères significatifs pour les identifica-teurs, sinon seulement 6 caractères. Si $STRICT est présent, seuls 6 caractères sont actifs. Certaines de ces directives peuvent se donner sur la ligne de commande d'appel du compilateur, ce qui permet des compilations différentes. Les correspondances sont : $DEBUG -4Yb $NODEBUG -4Nb (défaut) $DO66 -4Y6 $DECLARE -4Yd $NODECLARE -4Nd (défaut) $FREEFORM -4Yf $NOFREEFORM -4Nf (défaut) $STRICT -4Ys $NOTSTRICT -4Ns (défaut) $PACK[:{1|2|4}] -Zp[{1|2|4}] $TRUNCATE -4Yt $NOTRUNCATE -4Nt (défaut) Les options -4 peuvent se combiner entre elles comme par exemple : -4Y4Nt. 7.3.2.3 DÉVELOPPEMENT DE PROGRAMMES Le développement d'un programme comprend toujours au moins trois opérations : l'édition du fi-chier source comprenant les instructions, la compilation de ce fichier en langage machine et la liaison avec la bibliothèque du langage. L'environnement MS-FORTRAN facilite fortement ce travail. 1. Edition du fichier source Le fichier source est écrit au moyen d'un éditeur comme par exemple EDIT ou par l'éditeur adjoint au logiciel : M , cet éditeur devant être présent, donc chargé sur le disque. Chaque fois qu'une correc-

- 212 -


tion est à apporter au programme, il faut utiliser l'éditeur et appeler le fichier contenant les instructions. L'extension du fichier est : .FOR . Exemple : EDIT NOMFICH.FOR Le compilateur reconnaît ce fichier comme un fichier du langage MS-FORTRAN. 2. Compilation et assemblage du programme Le logiciel comprend un programme SETUP permettant de charger le compilateur optimiseur en mémoire, accompagné de ou des librairies nécessaires et de l'éditeur de lien adéquat. Nous ad-mettons que cette opération est effectuée correctement, l'implémentation par défaut prévoyant la pré-sence d'un coprocesseur arithmétique 8xx87. Le logiciel comprend plusieurs options de compilation permettant de fixer le mode de travail et la taille de la mémoire. Il est possible de créer plusieurs bibliothèques comme par exemple la bibliothèque pour exécuter les programmes avec le copro-cesseur et une autre bibliothèque pour obtenir un programme exécutable sans accès au copro-cesseur. Pour un programme complet, comprenant le programme principal et des sous-programmes, placés dans un seul fichier, la commande de compilation est excessivement simple : FL -Fs nomfich.for Cette commande appelle le compilateur, crée un fichier NOMFICH.LST contenant les instructions avec numérotation des lignes, liste des variables et des adresses, le résultat de la compilation, crée le fichier objet NOMFICH.OBJ en langage machine et assemble le programme pour le rendre exé-cutable sous la désignation NOMFICH.EXE . Cette commande est la plus courante avec le copro-cesseur. L'extension .for doit être présente. Le programme exécutable fera appel au coprocesseur. Si l'on désire rendre exécutable un programme qui doit aussi bien pouvoir travailler avec ou sans le coprocesseur, donc avec l'émulateur, la commande est alors : FL -FPi -Fs nomfich.for Si l'on désire compiler et assembler plusieurs fichiers source xxx.for , la commande sera : FL -Fs nomfich1.for nomfich2.for ou FL -FPi -Fs nomfich1.for nomfich2.for le nom du fichier exécutable étant : NOMFICH1.EXE . Attention : les paramètres de la ligne de commande doivent s'écrire exactement comme proposé en majuscule et minuscule, le caractère - pouvant se remplacer par la barre oblique / . 3. Compilation et assemblage séparés Il est possible de compiler sans assembler et assembler après compilation au moyen des com-mandes : FL -c nomfich.for pour engendrer le fichier NOMFICH.OBJ et d'assembler par : FL nomfich ou FL -FPi nomfich Les principaux paramètres de la ligne de commande sont (au total 59 paramètres) : -c compile le programme sans assembler -Fa[listfile ] produit un fichier liste en langage d'assemblage -Fc[listfile ] produit un fichier liste source & langage d'assemblage -Feexefile dénomme le fichier exécutable .EXE -Fl[listfile ] produit un fichier liste objet -Fm[listfile ] produit un fichier .MAP listant les segments -Foobjfile dénomme le fichier objet -Fs[listfile] produit un fichier liste source -HELP liste toutes les options de la commande FL -Od supprime l'optimisation de compilation -Zd introduit les numéros de ligne dans le fichier objet pour traitement par SYMDEB -Zi écrit dans le fichier objet toutes les informations symboliques nécessaires au dé-

- 213 -


bogueur CodeView 4. Autres facilités du logiciel Les possibilités complémentaires offertes par le logiciel sont : 4.1 Utilisation du débogueur CodeView pour rechercher les erreurs éventuelles après compilation et

dans la phase exécution. La compilation doit s'effectuer au moyen de la commande : FL /Zi /Od nomfich.for L'appel du logiciel s'effectue alors par la commande, le fichier NOMFICH.EXE devant exister : CV nomfich Ce logiciel comprend un fichier d'aide que l'on peut afficher à l'écran. Le sous-menu File contient l'ordre Exit pour quitter CodeView. Après utilisation et suppression des erreurs, compilez le program-me avec l'optimiseur, donc avec la commande normale citée ci-dessus. MS-FORTRAN peut utiliser des parties de programme écrites dans un autre langage de program-mation : - langage C , version Microsoft - BASIC (seulement sous condition) - Pascal , version Microsoft - langage d'assemblage Le programme LIB permet de créer, d'organiser et de maintenir des librairies de procédures constituées par des fonctions compilées ou assemblées. 7.3.2.4 INSTRUCTIONS SUPPLÉMENTAIRES Le langage FORTRAN Microsoft possède des extensions hors norme ANSI . L'emploi de ces instructions supplémentaires permet de mieux structurer la programmation et élimine presque en-tièrement l'utilisation des étiquettes. Le principal inconvénient de ce mode de programmation est de rendre le programme difficilement portable sur d'autres compilateurs (ce qui est l'une des qualités fondamentale du langage). Nous voulons traiter ici les principales particularités. 1. Instruction de sélection L'instruction de sélection transfère le déroulement du programme vers un bloc en fonction de la valeur d'une expression. L'expression doit être de type integer , logical ou character*1 . La forme générale de cette structure est : select case (testexpr) case (expressionlist) bloc d'instructions [case (expressionlist) bloc d'instructions] . . . . . . . . . . . . . . . . . . . [case default bloc d'instructions] end select avec : testexpr une expression de type integer , logicial ou character*1 , expressionlist une liste de valeurs qui doivent être constantes et de même type que test-

expr . Si testexpr correspond à l'une des valeurs citées dans la liste, le bloc d'instructions suivant est alors exécuté.

Il existe deux possibilités pour inclure des valeurs dans expressionlist : 1. de donner la liste des valeurs individuelles, séparées par la virgule; 2. de donner le domaine de validité des valeurs, séparé par : comme par exemple 5:10 ou 'I':'N' la

première valeur devant être inférieure à la seconde exprimée par exemple dans le code ASCII. Si la limite inférieure manque, comme par exemple :10 , toutes les valeurs inférieures ou égales à la

- 214 -


limite supérieure sont valables. Si la limite supérieure manque, comme par exemple 5: , toutes les valeurs supérieures sont valables. Une valeur ne peut apparaître que dans une seule liste.

Le bloc d'instructions ne doit pas contenir nécessairement des instructions exécutables. Des blocs vides peuvent s'introduire afin d'utiliser des valeurs particulières dans la sélection. L'instruction case default est optionnelle et doit rester unique dans la structure. Si la valeur de testexpr ne correspond à aucune valeur de expressionlist , le programme continue à l'instruction suivant end select . Les blocs de select case peuvent être imbriqués, mais chaque structure doit avoir un end select . En principe, toute boucle itérative ou autre sélection doit se contenir dans le même bloc. Il est interdit d'entrer dans un bloc de l'extérieur ou de passer d'un bloc à l'autre par une instruction de saut. Exemple : * * Définition d'une variable caractère * character*1 comcar * ................... * select case (comcar) case ('0') write (*,*) 'Sélection selon 0' case ('1':'9') write (*,*) 'Sélection de 1 à 9' case ('A','a') call anticipation case ('D','d') call depart case ('H','h') call aide_totale case ('S','s') call stop_programme case default write (*,*) 'Commande non reconnue' end select * 2. Type et variable composés Le langage MS-FORTRAN, à partir de la version 5.0, permet de créer et d'utiliser un type structu-ré que nous voulons nommé type composé semblable au type record défini dans Pascal. L'utilisation de ce type nécessite deux opérations : 1. la définition de la structure du type composé, 2. la définition de la ou des variables de ce type composé. a définition du type composé s'effectue par plusieurs instructions dont la syntaxe est donnée ici. structure / type_name / element_declaration(s) . . . . . . . . . . . . . . . . . end structure avec : type_name identificateur de type selon les conventions du langage. Il doit être

différent des autres variables, fonctions ou identificateur de type existant. Cet identificateur a une portée locale.

element_declaration(s) toute combinaison d'une ou de plusieurs variables et constructions union ; peut contenir des instructions record pour des types définis précédemment.

Cette structure définit donc un nouveau type de variable. La déclaration de variable s'effectue par l'instruction record comme par exemple :

- 215 -


structure / plein_nom / character*15 prenom character*20 nom character*25 rue integer*2 numero_postal character*20 localite end structure * record / plein_nom / nom1,nom2,nom3,nom_tout(50)

L'identificateur de champ à l'intérieur du bloc est local dans la structure. Il n'y a pas de conflit entre identificateurs de champs et de variables. Un champ particulier est atteint en précisant l'identificateur de variable, suivi d'un point et de l'identificateur de champ comme par exemple : nom1.numero_postal . Une structure ne peut pas dépasser 65536 octets. Les particularités complémentaires existant dans la déclaration d'un type composé sont définies ci-après.

2.1 Instruction union . . . end union Cette structure permet de stocker des groupes d'instructions, définis dans un bloc map , dans les mêmes places en mémoire. Syntaxe : union map_statement map_statement . . . . . . . . . . end union avec : map_statement une déclaration map selon syntaxe ci-dessous. Un bloc union ne peut apparaître que dans un bloc structure . Chaque bloc union doit se ter-miner par end union et cette instruction ne peut s'introdure qu'à la fin d'un seul bloc union . L'instruction union est similaire à common mais les variables peuvent être contiguës ce qui aug-mente la flexibilité des assignements. Exemple : union map character*20 chaine1 character*10 chaine2(6) end map map integer*2 number(10) integer*4 intvar(10) integer*2 date(10) end map end union

La directive de compilation $Pack ou -Zp contrôlent la manière d'aligner les variables de la struc-ture à l'adresse d'octet.

2.2 Définition d'un groupe de types de variables par map Pour effectuer une déclaration d'un groupe de variables dans une instruction structure , utilisez : map type_declaration(s) . . . . . . . . . . end map avec : type_declaration une déclaration de variable de tout type standard ou record .

- 216 -


Un bloc map . . . end map ne peut apparaître que dans un bloc union . . . end union . Les variables sont stockées dans des places contiguës en mémoire dans l'ordre des déclarations. Il doit exister au moins deux blocs map dans une union .

2.3 Spécification de variables structurées La déclaration de variables de type composé s'effectue selon la syntaxe : record / type_name / vname [ [ attrs ] ] [ (dim) ] [ , . . . avec : type_name identificateur du type composé défini dans structure , vname un identificateur de variable, de tableau, de ce type composé , attrs une liste d'attributs, séparés par la virgule, dim dimension du tableau Voir l'exemple ci-avant. 3. Passage de paramètres tableaux L'organisation générale du système d'exploitation DOS est basée sur la segmentation de la mé-moire, un segment pouvant contenir au maximum 64 Koctets. Cette limitation n'est pas favorable à l'utilisation de grands tableaux numériques dans les programmes comme par exemple les matrices. L'implémentation MS-FORTRAN présente les caractéristiques générales suivantes : 1. Un tableau dimensionné numériquement, dont l'occupation en mémoire est supérieure à la limite

du segment, est fractionné en deux ou plusieurs segments par les possibilités de l'implé-mentation. L'adresse des éléments se compose de deux parts : l'adresse du segment et l'adresse du déplacement (offset), ces deux grandeurs étant stockées dans quatre octets.

2. Les éléments d'un tableau à dimensions variables, déclarés dans un sous-programme, sont repérés normalement seulement par le déplacement (offset). Lors de la compilation de cette unité de programme, le compilateur réserve une adresse à deux octets et l'occupation en mémoire ne pourra jamais dépasser la taille d'un segment.

3. Si le tableau à dimensions variables dans un sous-programme dépasse la taille fatidique de 64 Koctets, alors il est nécessaire de compléter la déclaration du tableau, soit pas l'attribut huge, soit par la directive de compilation $large .

Exemple : Soit un tableau a dépassant la taille d'un segment et soit les parties de programmes citées. program demonstration_taille real a(160,160) ............................ end

Variante avec attribut huge placé entre crochets : subroutine change_tableau (n,a[huge]) integer n real a(n,n) ............................ end

Variante avec directive de compilation $LARGE placé avant le début du sous-programme : $LARGE:a subroutine change_tableau (n,a) integer n real a(n,n) ............................ end 4. Liste d'un groupe d'identificateurs L'instruction namelist , existant dans de nombreuses implémentations de FORTRAN, permet de grouper un ensemble d'identificateurs de variable pour les lire ou les écrire dans des instructions read et write . La syntaxe est :

- 217 -


namelist / namlst / varlist [ / namlist / varlist ] avec : namlst l'identificateur pour un groupe de variables, varlist une liste d'identificateurs de variables ou de tableaux, les types structurés et les

paramètres formels n'étant pas autorisés. Si la liste est utilisée dans une instructions write , la liste des variables avec leurs propres valeurs est écrite dans un fichier ou affichée à l'écran. Si la liste est utilisée dans une instruction read , le fichier correspondant à unit est connecté ou l'entrée utilisateur est enclenchée pour recevoir les valeurs des variables de la liste. Sans mise en forme, les valeurs sont écrites dans l'écriture stan-dard. Exemple :

integer i2,i4,i6 real r2,r4,r6 complex z1,z2,z3 namelist / exemple / i2,i4,i6,r2,r4,r6,z1,z2,z3 ..................... write (*,exemple) 7.3.2.5 INSTRUCTIONS POUR GRAPHIQUES À L’ÉCRAN L'implémentation du langage MS-FORTRAN, version 5.0, comprend environ 70 sous-programmes accédant aux diverses possibilités des écrans des micro-ordinateurs de l’époque utilisant le système d'exploitation DOS ou OS/2 : EGA , VGA , MCGA et Hercules. Ces sous-programmes se composent de fonctions et de subroutines. Afin de distinguer ces deux genres de routines dans la syntaxe, les sous-programmes de type subroutine sont accompagnés de l'instruction call . . . dans l'écriture de ces routines et fonctions. Toutes ces routines sont écrites en langage C et sont accessibles à travers des fichiers de déclaration à inclure dans les programmes source ainsi qu'une librairie graphique à adjoindre au fichier .OBJ lors de l'édition de lien : 1. fichiers de déclarations et de connexion : FGRAPH.FI et FGRAPH.FD 2. librairie graphique sous DOS : GRAPHICS.LIB Les constructions graphiques sont basées sur la définition de points d'écran (pixels) et de cou-leurs à disposition pour chaque carte graphique. L'origine du système de coordonnées (0,0) se trouve à gauche en haut de l'écran. Il est possible d'accéder à 2, 4, 8, 16 ou 256 couleurs selon le pilote et le mode choisis. L'indice de couleur est toujours une valeur de type integer*2 et une valeur de couleur est de type integer*4 . Remarque complémentaire Ces constructions graphiques utilisent à nouveau une collection de commandes propres à MS-FORTRAN. Nous terminons ici l’exposé de la version 5.0 FORTRAN de Microsoft..

- 218 -


7.3.3 IMPLEMENTATION : VAX-11 FORTRAN La documentation concernant cette implémentation du langage FORTRAN se trouve dans le ma-nuel de la firme Digital Equipment Corporation , Maynard , Massachusetts, USA : Programming in VAX - FORTRAN AA-D034D-TE Software Version : V 4.0 Le système d'exploitation des terminaux travaillant sur VAX-785 ou Micro-VAX est : VMS . 7.3.3.1 PARTICULARITÉS Les particularités de l'implémentation sont écrites en bleu dans le manuel de référence du langa-ge, l'implémentation étant la plus riche des langages présentés dans ce document. Nous donnons ci-après quelques unes de ces particularités. 1. Identificateurs Les caractères admissibles sont les 52 lettres majuscules et minuscules, les chiffres 0 à 9, les ca-ractères $ et _ , le premier caractère devant être une lettre. L'identificateur peut comprendre jusqu'à 31 caractères. Les noms des entités suivantes doivent rester uniques dans tout le programme : sous-programmes function et subroutine , blocs communs, programme principal, block data , points d'en-trée additionnelle par entry . 2. Écriture des instructions La position des caractères suit les règles générales données dans le cours sous 1.1 . Un C (ou c) ou * dans la première colonne indique un commentaire; un ! placé dans la première ou dans toute co-lonne signifie que le texte subséquent est un commentaire. Les instructions s'écrivent dans les colon-nes 7 à 72 , optionnellement jusqu'à 132 colonnes. L'introduction des instructions au moyen du tabu-lateur est possible, mais pas recommandé si l'on travaille en réseau sur plusieurs systèmes d'exploi-tation et implémentations. 3. Type de données Les types de données à disposition sont : 1. entiers : integer , byte , integer*2 , integer*4 byte : domaine -128 à 127 2. réels : real , real*4 , real*8 , double precision , real*16 3. complexes : complex , complex*8 , complex*16 , double complex 4. booléens : logical , byte , logical*1 , logical*2 , logical*4 byte : peut contenir une des valeurs logiques : true. ou .false. 5. caractères : character*lën avec 1 £ len £ 65535. 6. tableaux : de type simple, le nombre de dimensions pouvant aller de 1 à 7 les indices peuvent être des expressions arithmétiques converties en entier. 7. Records : VAX-11 FORTRAN reconnaît cette structure hors norme. 4. Instructions Les instructions selon norme ANSI sont applicables dans la programmation des instructions. Les instructions supplémentaires à disposition sont données ci-après. - namelist définit une liste de variables simples et de tableaux associées à une liste - record crée une structure enregistrement, définie dans un bloc de déclarations - volatile permet d'optimiser le code - do while structure tant que - end do fin de la structure itérative : do ... ou do while - rewrite permet de transférer des données vers un fichier indexé

- 219 -


- accept entrée de données avec unité préconnectée - type sortie de données avec unité préconnectée - encode transfert de données entre représentations interne et externe - decode pour compatibilité avec FORTRAN , version IV Le descripteur $ empêche le retour à la ligne dans l'instruction write ( ... ) . Les descripteurs O pour octal et Z pour hexadécimal sont à disposition. L'implémentation reconnaît aussi les descripteurs par défaut pour les divers types de données. 5. Fichiers L'ouverture d'un fichier à accès séquentiel, direct ou indexé prévoit les clauses et les options sui-vantes : - access 'sequential' 'direct' , 'keyed' , 'append' - blocksize espression numérique - buffercount expression numérique - carriagecontrol 'fortran','Iist','none' - defaultfile expression chaîne de caractères - dispose 'keep' ou 'save' 'delete' 'print' 'print/delete' , 'submit' 'submit/delete' - maxrec expression numérique (seulement accès direct) - organisation 'sequential' 'relative' 'indexed' - readonly protection contre l'écriture - recordtype 'fixed' 'variable' 'segmented' , 'stream' ,’ stream_CR' , 'stream_LF' - shared accès mufti-utilisateurs autorisé Les fichiers indexés sont des fichiers avec une organisation séquentielle. les enregistrements étant classés selon une clef. Une table interne gère l'ensemble. 6. Fonctions "intrinsic" Les fonctions fondamentales du langage sont présentes dans la librairie, complétées par les fonc-tions pour les types supplémentaires. Dans la liste ci-après, nous laissons de côté les fonctions pour le type real*16, nécessitant un processeur arithmétique supplémentaire. Fonctions de conversion de type : dcmplx , dreal , iint , jint , iidint , jidint , iifix , jifix Fonctions absolue pour complex*16 : cdabs(cmpll 6) , résultat : fonction de type real*8 Fonctions d'opérateurs complexes : cdsqrt(cmpI16), cdexp(cmpll6) , cdlog(cmpI16) Fonctions trigonométriques : cdsin(cmpll 6) , cdcos(cmpll 6) , (les fonctions "generic" sin , cos sont également valables pour le type complex*16) Fonctions "generic" pour arguments en degrés, types real*4 et real*8 sind , cosd , tand , asind , acosd , atand , atan2d Fonctions de manipulation de bits : iand , ior , ieor , not , ishft , ibits , ibset , ibtest , ibcIr , ishftc Génération de nombres pseudo-aléatoires (valeurs comprises entre 0 et < 1.0) fonction : ran(i) i est une expression entière de type integer*4 , choisir un nombre impair très grand. Sous-programmes complémentaires : call date (buf) buf chaîne de 9 caractères date dd-mmm-yy call idate (i,j,k) i,j,k variables de type entier i mois, j jour, k année call exit termine le programme call time (buf) buf chaîne de 8 caractères hh:mm:ss 7.3.3.2 DIRECTIVES DE COMPILATION Les directives de compilation, placées dans le programme source, appelées Compilation Control Statements, sont au nombre de trois.

- 220 -


Instruction : INCLUDE L'instruction include 'nomfich' permet d'appeler un fichier ou une librairie source lors de la compila-tion. Cette instruction n'a pas d'effet sur l'exécution. Elle peut se compléter par les options à incorporer : /list ou /nolist. Instruction : OPTIONS Cette instruction permet de confirmer ou remplacer les qualificatifs donnés dans la commande d'appel de FORTRAN . Instruction : DICTIONARY Cette instruction incorpore le dictionnaire : VAX Common Data Dictionary dans le fichier source pen-dant la compilation. Elle peut se donner n'importe où dans le programme. 7.3.3.3 DEVELOPPEMENT DE PROGRAMME Le développement d'un programme comprend également les trois opérations fondamentales soit l'édition du fichier avec le programme source, la compilation ou traduction en langage machine et fina-lement l'assemblage des unités. L'environnement VAX-11 donne au programmeur de nombreuses possibilités de faciliter ces opérations, en particulier grâce à un langage de création de commandes : DCL (Digital Command Language). Nous donnons ci-après les manipulations minimales pour rendre un programme exécutable. 1. Edition du fichier source Le premier pas dans la création d'un fichier source est l'édition d'un document grâce à l'utilisation de l'éditeur EDT . Cet éditeur est très efficace car les touches du pavé numérique sont dédicacées à des fonctions particulières. L'appel de l'éditeur s'effectue par la commande : $ EDIT/EDT [/qualificatifs] nomfich Le nom de fichier nomfich est terminé par l'extension FOR. Exemple : EDIT/EDT programl.for L'écran affiche si ce fichier existe dans le répertoire courant. Si ce n'est pas le cas, il ouvre un nouveau fichier sous ce nom. Le texte frappé au clavier se trouve dans la mémoire principale. Cet édi-teur possède trois mémoires complémentaires, journal et paste. Pour quitter l'éditeur pleine page, donnez : Ctrl-Z suivi d'EXIT si l'on désire conserver le fichier, de QUIT pour quitter sans enregis-trement de cette version. Pendant l'édition, il est possible d'accéder au fichier d'aide par pression sur la seconde touche, rangée supérieure, du pavé numérique. La première touche de cette rangée est la touche à fonction multiple : GOLD . 2. Compilation du fichier source L'appel du compilateur, pour la traduction du fichier source en langage machine, se donne au moyen de la commande : $ FORTRAN [/qualificatifs] liste nomfic /qualificatifs indique des options à introduire pendant la compilation, le nombre d'options pouvant

s'introduire sur cette ligne est très grand liste-nomfich spécifie le(s) fichier(s) source à compiler, les noms étant séparés par la virgule Exemple de commande courante pour le fichier : program1.for $ fortran /list program1 Cette commande appelle le fichier program1.for et produit le fichier program1.obj ainsi que le fichier program1.lis contenant les instructions numérotées et le bilan de la compilation. 3. Assemblage des fichiers objet Pour produire un programme exécutable, à partir d'un ou de plusieurs fichiers en langage machi-ne, présentant l'extension .OBJ , la commande est simplement : $ LINK [/qualificatifs] liste_nomfich /qualificatifs options d'assemblage

- 221 -


liste_nomfich liste du ou des fichiers à introduire dans l'assemblage, séparés par la virgule. Sans option complémentaire, l'éditeur de lien produit un fichier exécutable dont le nom est celui du premier fichier de la liste.

Toujours pour le fichier précédent, la commande de l'assemblage se fait par : $ link program1 le système produisant un fichier exécutable : PROGRAM1.EXE. Enfin, pour lancer le programme, il faut donner la commande : $ RUN nomfich Les divers fichiers sont conservés sur le disque, chaque fichier ayant une version. Il est recom-mandé d'effacer tous les fichiers inutiles, en particulier les fichiers .OBJ , et les anciennes versions. 5. Autres facilités du logiciel L'environnement VAX-11 offre de nombreuses facilités dans le développement des programmes : - introduction du langage de commande pour faciliter l'introduction des qualificatifs, - création d'un bibliothèque du programme et des sous programmes, - débogueur pour la recherche des erreurs, - accès aux autres langages de programmation. Les manuels spécifiques donnent des renseignements détaillés sur le domaine d'application de ces logiciels et la mise en oeuvre des possibilités. 7.3.3.4 SÉQUENCES DE CONTRÔLE ESCAPE Les séquences de contrôle ESCAPE sont des fonctions de gestion d'écran ou d'imprimante selon ANSI . Si le système de gestion d'écran est conforme à cette norme, il est possible d'obtenir un très grand nombre de fonctions d'affichage. La syntaxe des séquences de contrôle est : char(27) //'[symbole' avec : char(27) correspond au code ASCII décimal de ESCAPE // opérateur de concaténation (optionnel, voir exemples du cours) '[ début de la chaîne de caractères symbole' un ou plusieurs caractères définissant la gestion de l'écran ou de l'imprimante Dans les exemples suivant, les symboles utilisés sont les symboles généraux qui doivent se pro-grammer conformément à la syntaxe du langage. Les séquences de contrôle données ci-après sont tirées du manuel Vectra MS-DOS : User's Refe-rence. Les écrans de la firme DEC possèdent des séquences de contrôle complémentaires ou éven-tuellement différentes de celles du tableau. Les séquences de contrôle pour micro-ordinateurs se trouvent dans le fichier : ANSI.SYS Le fichier doit être accessible au moment du chargement de DOS et figurer dans le fichier de con-figuration du système CONFIG.SYS par : DEVICE = ANSI.SYS

- 222 -


Tableau 7.8

SEQUENCES DE CONTROLE ANSI AU MOYEN D'ESCAPE

Symbole Fonction

11,c1H 11A 11B c1C c1D

11,c1f 2J K

----------

0 1 4 5 7 8 30 31 32 33 34 35 36 37 40 41 42 43 44 45 46 47

0 1 2 3 4 5 6

Position du curseur déplace le curseur à la ligne 11, colonne c1 déplace le curseur en haut de 11 lignes déplace le cruseur en bas de 11 lignes déplace le curseur à droite de c1 colonnes déplace le curseur à gauche de c1 colonnes déplace le curseur à la ligne 11, colonne c1 si 11 et cl sont absents, place à la position HOME efface l'écran efface jusqu'à la fin de la ligne -------------------------------------------------------------

Choix des caractères graphiques (SGR) Syntaxe générale : ESC[#; ...,#m où # représente un nombre attributs d'écran par défaut, fond noir, lettres en blanc lettres haute densité souligné intermittent vidéo inverse effaçage ON (invisible) texte noir texte rouge texte vert texte jaune texte bleu texte magenta texte cyan texte blanc fond noir fond rouge fond vert fond jaune fond bleu fond magenta fond cyan fond blanc Exemple : ESC[32;40m texte vert sur fond noir Utilisez des caractères haute densité pour la couleur correcte --------------------------------------------------------------- Définition d'écran (Vectra) Syntaxe : ESC[=#h avec : # une valeur numérique écran blanc – noir 40 x 25 écran couleur : 40 x 25 écran noir – blanc 80 x 25 écran couleur : 80 x 25 écran couleur : 3 20 x 200 écran noir blanc 320 x 200 écran couleur : 640 x 200

- 223 -

- 224 -

- Code ASCII -

CODE ASCII

Code décimal : de 0 à 63

Déc Oct Hex Car Déc Oct Hex Car 000 000 000 NUL 032 040 020 esp 001 001 001 SOH 033 041 021 ! 002 002 002 STX 034 042 022 ≤ 003 003 003 ETX 035 043 023 # 004 004 004 EOT 036 044 024 $ 005 005 005 ENQ 037 045 025 % 006 006 006 ACK 038 046 026 & 007 007 007 BEL 039 047 027 ‘ 008 010 008 BS 040 050 028 ( 009 011 009 HT 041 051 029 ) 010 012 OOA LF 042 052 02A * 011 013 OOB VT 043 053 02B + 012 014 00C FF 044 054 02C , 013 015 OOD CR 045 055 02D - 014 016 OOE SO 046 056 02E . 015 017 OOF SI 047 057 02F / 016 020 010 DLE 048 060 030 0 017 021 011 DC1 049 061 031 1 018 022 012 DC2 050 062 032 2 019 023 013 DC3 051 063 033 3 020 024 014 DC4 052 064 034 4 021 025 015 NAK 053 065 035 5 022 026 016 SYN 054 066 036 6 023 027 017 ETB 055 067 037 7 024 030 018 CAN 056 070 038 8 025 031 019 EM 057 071 039 9 026 032 01A SUB 058 072 03A : 027 033 01B ESC 059 073 03B ; 028 034 01C FS 060 074 03C < 029 035 01D GS 061 075 03D = 030 036 01E RS 062 076 03E > 031 037 01F US 063 077 03F ? Code utilisé : Déc code décimal Oct code octal hexa code hexadécimal Car caractère

- 225 -


CODE ASCII

Code décimai : de 64 à 127

Déc Oct Hex Car Déc Oct Hex Car 064 100 040 @ 096 140 060 ` 065 101 041 A 097 141 061 a 066 102 042 B 098 142 062 b 067 103 043 C 099 143 063 c 068 104 044 D 100 144 064 d 069 105 045 E 101 145 065 e 070 106 046 F 102 146 066 f 071 107 047 G 103 147 067 g 072 110 048 H 104 150 068 h 073 111 049 I 105 151 069 i 074 112 04A J 106 152 06A j 075 113 04B K 107 153 06B k 076 114 04C L 108 154 06C l 077 115 04D M 109 155 06D m 078 116 04E N 110 156 06E n 079 117 04F 0 111 157 06F o 080 120 050 P 112 160 070 p 081 121 051 Q 113 161 071 q 082 122 052 R 114 162 072 r 083 123 053 S 115 163 073 s 084 124 054 T 116 164 074 t 085 125 055 U 117 165 075 u 086 126 056 V 118 166 076 v 087 127 057 W 119 167 077 w 088 130 058 X 120 170 078 x 089 131 059 Y 121 171 079 y 090 132 05A Z 122 172 07A z 091 133 05B [ 123 173 07B { 092 134 05C \ 124 174 07C | 093 135 05D ] 125 175 07D } 094 136 05E ^ 126 176 07E ~ 095 137 05F _ 127 177 07F eff Code utilisé : Déc code décimal Oct code octal hexa code hexadécimal Car caractère

- 226 -

INDEX ALPHABETIQUE DES IDENTIFICATEURS

D'INSTRUCTIONS, FONCTIONS ET OPERATEURS FORTRAN-77

'direct' 142 Lc 114,120 conjg 69 'formatted' 141,144 SP 115 continue 45 'new' 147 SS 115 cos 70 'no' 142,144,147 TLc 115,125 cosh 71 'null' 142 TRc 115,125 data 39 'old' 147 Tc 115,125 dble 67 'scratch' 147 abs 68,88 dim 69 'sequential' 142 access 141 dimension 29 'unformatted' 144 acos 71 direct 142 'unknown' 142,144,147 aimag 69 do 58 'unknown' 147 aint 68 do implicite 132 'yes' 142,144,147 anint 68 do while 79 'zero' 142 asin 71 double precision * 30 assign ...to... 48 - tableau 27 ** 30 atan 71 - type 15 + 30 atan2 71 - variable 23 - 30 backspace 154 dprod 69 .and. 35 blank 142 else 52 .eq. 34 block data 110 else if...then 52 .eqv. 35 call 88 end 45,142 .false. 20 char 67 end do 58 .ge. 34 character end if 32 .gt. 34 - tableau 28 endfile 152 .le. 34 - type 17 entry 100 .lt. 34 - variable 24 equivalence 108 .ne. 34 character*(*) err 143 .neqv. 35 - paramètre formel 25 exist 143 .not. 35 character*n exp 70 .or. 35 - tableau 28 external 77 .true. 20 - variable 24 file 143 / 30 close 150 fmt 144 / descripteur 115,124 cmplx 67 form 144 // 33 common blanc 105 format 112 : 115 common identifié 106 formatted 144 A[c] 114,121 complex function 97 BN 115 - tableau 27 goto calculé 49 BZ 115 - type 16 goto imposé 48 Caracteres A..Z,a..z 6 - variable 24 goto incondit. 48 Caracteres speciaux 6 complex*16 ichar 67 Chiffres 0..9 6 - tableau 27 if arithmét. 51 Dc.d 114,118 - type 16 if logique 52 Ec.d 114,118 - variable 24 if ... then 53 Fc.d 114,118 complex*8 implicit 22 Gc.d 114,116 - tableau 27 index 72 Ic[.m] 114,115 - type 16 inquire 152 - variable 24 int 67

- 227 -

INDEX ALPHABETIQUE DES IDENTIFICATEURS

D'INSTRUCTIONS, FONCTIONS ET OPERATEURS FORTRAN-77

(SUITE) integer - tableau 27 - variable 23 - tableau 23 - type 16 real*4 - type 14 - variable 24 - tableau 26 - variable 23 max 67 - type 15 integer*2 min 69 - variable 23 - tableau 26 mod 68 real*8 - type 14 nHc...c 114,122 - tableau 27 - variable 23 nX 115,124 - type 15 integer*4 name 145 - variable 23 - tableau 26 named 145 rec 146 - type 14 nextrec 145 recl 146 - variable 23 nint 68 return 88 intrinsic 66 number 146 rewind 153 iostat 145 open 148 save 107 kP 115,120 opened 146 sequential 147 len 72 parameter 38 sign 68 lge 72 pause 45 sin 70 lgt 72 print liste 135 sinh 71 lle 72 print * 44 sqrt 70 llt 72 program 11 status 147 log 70 read fichier 151 stop 47 log10 70 read liste 134 subroutine 092 logical read * 43 tan 70 - tableau 27 real tanh 71 - type 16 - fonction 67 type declaration 25 - variable 24 - tableau 35 unformatted 147 logical*2 - type 14 unit 147 - tableau 27 - variable 23 write fichier 151 - type 16 real*16 write liste 135 - variable 24 - tableau 35 logical*4

- 228 -

ÉLÉMENTS DE PROGRAMMATION EN FORTRAN - 77

Documents

Transcript of ÉLÉMENTS DE PROGRAMMATION EN FORTRAN - 77