Cours pour débuter et avancé avec le langage Fortran


Télécharger Cours pour débuter et avancé avec le langage Fortran
3.53.5 étoiles sur 5 a partir de 1 votes.
Votez ce document:

Télécharger aussi :


Table des matières I

1    Introduction Historique

Compatibilité norme 77/90

Apports de Fortran 90

Apports de Fortran 95 bibliographie documentation

2    Généralités

Structure d’un programme

Compilation, édition des liens, exécution

Éléments syntaxiques

Les identificateurs

Le « format libre »

Les commentaires

Le « format fixe »

Les déclarations

Typage des données : paramètre KIND

Typage des données : paramètre KIND (nouveautés norme 2008)

3    Types dérivés

Définition et déclaration de structures

Initialisation (constructeur de structure)

Constructeur de structure : norme 2003

Symbole % d’accès à un champ

Types dérivés et procédures

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

2 / 314

Table des matières II

Types dérivés et entrées/sorties

4    Programmation structurée

Introduction

Boucles DO

Le bloc SELECT-CASE La structure block

5    Extensions tableaux

Définitions (rang, profil, étendue, )

Manipulations de tableaux (conformance, constructeur, secti

Initialisation de tableaux

Sections de tableaux

Sections irrégulières

Tableau en argument d’une procédure (taille et profil implici

Section de tableau non contiguë en argument d’une procédu

Fonctions intrinsèques tableaux

Interrogation (maxloc, lbound, shape, )

Réduction (all, any, count, sum, . ..)

Multiplication (matmul, dot_product, . ..)

Construction/transformation (reshape, cshift, pack, spread, transp

Instruction et bloc WHERE

Expressions d’initialisation

Exemples d’expressions tableaux

6 Gestion mémoire

Expressions de spécification

on, taille, )

tes)

re

ose, )

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

3 / 314

Table des matières III

Tableaux automatiques

Tableaux dynamiques ALLOCATABLE, profil différé

Argument muet ALLOCATABLE : norme 2003

Composante allouable d’un type dérivé : norme 2003

Allocation d’un scalaire ALLOCATABLE : norme 2003

Allocation/réallocation via l’affectation : norme 2003

Procédure MOVE_ALLOC de réallocation : norme 2003

7 Pointeurs

Définition, états d’un pointeur

Déclaration d’un pointeur

Symbole =>

Symbole = appliqué aux pointeurs

Allocation dynamique de mémoire

Imbrication de zones dynamiques

Fonction NULL() et instruction NULLIFY

Fonction intrinsèque ASSOCIATED

Situations à éviter

Déclaration de « tableaux de pointeurs »

Passage d’un pointeur en argument de procédure

Passage d’une cible en argument de procédure Pointeur, tableau à profil différé et COMMON Liste chaînée

8 Interface de procédures et modules

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

4 / 314

Table des matières IV

Interface implicite : définition

Interface implicite : exemple

Arguments : attributs INTENT et OPTIONAL

Passage d’arguments par mot-clé

Interface explicite : procédure interne

Interface explicite : 5 possibilités

Interface explicite : bloc interface

Interface explicite : ses apports

Interface explicite : module et bloc interface

Interface explicite : module avec procédure

Cas d’interface explicite obligatoire

Argument de type procédural et bloc interface

9   Interface générique

Introduction

Exemple avec module procedure

Exemple : contrôle de procédure F77

10   Surcharge ou création d’opérateurs

Introduction

Interface operator

Interface assignment

11   Contrôle de visibilité, concept d’encapsulation et gestion de zon

Introduction

Instructions PRIVATE et PUBLIC

es dynamiques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

5 / 314

Table des matières V

Attributs PRIVATE et PUBLIC

Type dérivé semi-privé

Exemple avec contrôle de la visibilité

Paramètre ONLY de l’instruction USE

12   Procédures récursives

Clauses RESULT et RECURSIVE Exemple : suite de Fibonacci

13   Nouveautés sur les E/S

Accès aux fichiers pré-connectés

OPEN (status, position, pad, action, delim)

INQUIRE (recl, action, iolength, )

Entrées-sorties sur les fichiers texte (advance=’no’)

Paramètres IOSTAT et IOMSG de l’instruction READ

Paramètres IOSTAT et IOMSG de l’instruction READ

Instruction NAMELIST

Spécification de format minimum

14   Nouvelles fonctions intrinsèques Accès à l’environnement,

Précision/codage numérique : tiny/huge, sign, nearest, spaci

Mesure de temps, date, nombres aléatoires

Transformation (transfer)

Conversion entiers/caractères (char, ichar, )

Comparaison de chaînes (lge, lgt, lle, llt)

ng,

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

6 / 314

Table des matières VI

Manipulation de chaînes (adjustl, index, )

Opérations sur les bits (iand, ior, ishft, )

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

7 / 314

Introduction

1    Introduction Historique

Compatibilité norme 77/90

Apports de Fortran 90

Apports de Fortran 95 bibliographie documentation

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et m

odules

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

8 / 314

Introduction

9   Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

9 / 314

Introduction

Historique

•  Code machine (notation numérique en octal);

•  Assembleurs de codes mnémoniques;

•  1954 : projet création du premier langage symbolique FORTRAN par John Backus d’IBM (MathematicalFORmulaTRANslating System) :

•  Efficacité du code généré (performance) ;

•  Langage quasi naturel pour scientifiques (productivité, maintenance, lisibilité).

•  1957 : Livraison des premiers compilateurs ;

•  1958 : Fortran II (IBM) ?sous-programmes compilables de façon indépendante.

•  Généralisation aux autres constructeurs mais :

•  divergences des extensions ?nécessité de normalisation;

•  ASA American Standards Association (ANSI American Nat. Standards Institute).

Comité chargé du développement d’une norme Fortran.

•  1966 : Fortran IV (Fortran 66) ;

•  Évolution par extensions divergentes. ..

•  1977 : Fortran V (Fortran 77).

quasi compatible :

aucune itération des boucles nulles (DO I=1,0)

•  Nouveautés principales :

•  type caractère ;

•  IF-THEN-ELSE;

•  E/S accès direct et OPEN.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               10 / 314

Introduction

Historique

•  Travail des comités X3J3/ANSI et WG5/ISO pour moderniser Fortran 77 :

•  Standardisation : inclusion d’extensions;

•  Développement : nouveaux concepts déjà exploités par langages plus récents APL, Algol, PASCAL, Ada;

•  Performances en calcul scientifique; • Totalement compatible avec Fortran 77.

•  1991/1992 : Norme Fortran 90 (ISO et ANSI);

•  1994 : Premiers compilateurs Fortran 90 Cray et IBM;

•  1997 : Norme Fortran 95 (ISO et ANSI);

•  1999 : Premiers compilateurs Fortran 95 sur Cray T3E puis IBM RS/6000;

•  septembre 2004 : Norme Fortran 2003 (ISO et ANSI);

•  octobre 2010 : Norme Fortran 2008 (ISO et ANSI).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               11 / 314

Introduction

Compatibilité norme 77/90

Compatibilité norme 77/90

•  La norme 77 est totalement incluse dans la norme 90.

•  Quelques comportements différents :

•  beaucoup plus de fonctions/sous-progr. intrinsèques ? risque d’homonymie avec procédures externes Fortran 77 et donc de résultats différents! EXTERNAL recommandé pour les procédures externes non intrinsèques,

•  attribut SAVE automatiquement donné aux variables initialisées par l’instruction DATA

(en Fortran 77 c’était « constructeur dépendant »);

•  E/S - En lecture avec format, si Input list > Record length (ou plus exactement si une fin d’enregistrement est atteinte avant la fin de l’exploration du format associé à la valorisation de l’input list) :

•  OK en Fortran 90 car au niveau de l’OPEN, PAD="YES" pris par défaut.

•  Erreur en Fortran 77!

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               12 / 314

Introduction

Apports de Fortran 90

Apports de Fortran 90

•  Procédures internes (CONTAINS), modules (USE);

•  « Format libre », identificateurs, déclarations;

•  Précision des nombres : KIND? portabilité;

•  Objets de types dérivés ;

•  DO–END DO, SELECT CASE, WHERE;

•  Extensions tableaux : profil, conformance, manipulation, fon

•  Allocation dynamique de mémoire (ALLOCATE);

•  Pointeurs ;

•  Arguments : OPTIONAL, INTENT, PRESENT. Passage par mo

•  Bloc interface, interface générique, surcharge d’opérateurs;

•  Procédures récursives;

•  Nouvelles fonctions intrinsèques;

•  Normalisation directive INCLUDE.

ctions;

t-clé ;

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

13 / 314

Introduction

Apports de Fortran 95

Apports de Fortran 95

•  FORALL(i=1:n,j=1:m,y(i,j)/=0.) x(i,j)=1./y(i,j) (cf. Annexe C page 313).

•  Les attributs PURE et ELEMENTAL pour des procédures sans effet de bord et pour le second des arguments muets élémentaires mais appel possible avec arguments de type tableaux

(cf. Annexe C pages 309, 311).

•  Fonction intrinsèque NULL() pour forcer un pointeur à l’état nul y compris lors de sa déclaration (cf. chap. 7 page 145).

•  Libération automatique des tableaux dynamiques locaux n’ayant pas l’attribut SAVE (cf. chap. 6 page 125).

•  Valeur initiale par défaut pour les composantes d’un type dérivé (cf. chap. 3 page 55).

•  Fonction intrinsèque CPU_TIME(cf. chap. 14 page 245).

•  Bloc WHERE : imbrication possible (cf. chap. 5 page 115).

•  Expressions d’initialisation étendues (cf. chap. 5 page 115).

•  MAXLOC/MINLOC : ajout argument dim(cf. Chap. 5 page 89).

•  Ajout generic_spec(cf. Chap. 9 page 187) au niveau de l’instruction END INTERFACE [generic_spec]

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               14 / 314

Introduction

bibliographie

bibliographie

•  Adams, Brainerd, Hendrickson, Maine, Martin, Smith, The Fortran 2003 Handbook, Springer, 2009, (712 pages), ISBN 978-1-84628-378-9;

•  Walters S. Brainerd, Guide to Fortran 2008 Programming, Springer, 2015,

ISBN 978-1-4471-6758-7;

•  Chivers Ian, Sleightholme Jane, Introduction to Programming with Fortran,

2015, ISBN 978-3-319-17701-4;

•  Michael Metcalf, John Reid, Malcom Cohen, Modern Fortran Explained, 2011,

ISBN 978-0199601424;

•  Norman S. Clerman, Walter Spector, Modern Fortran : Style and Usage,

Cambridge University Press, 2012, ISBN 978-0521730525;

•  Arjen Markus, Modern Fortran in Practice, Cambridge University Press, juin 2012, (272 pages), ISBN 978-1-10760-347-9;

•  Chamberland Luc, Fortran 90 : A Reference Guide, Prentice Hall,

ISBN 0-13-397332-8;

•  Delannoy Claude, Programmer en Fortran 90 – Guide complet, Eyrolles, 1997,

(413 pages), ISBN 2-212-08982-1;

•  Dubesset M., Vignes J., Les spécificités du Fortran 90, Éditions Technip, 1993, (400 pages), ISBN 2-7108-0652-5;

•  Ellis, Phillips, Lahey, Fortran 90 Programming, Addisson-Wesley, 1994,

(825 pages), ISBN 0-201-54446-6;

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               15 / 314

Introduction

bibliographie

•  Kerrigan James F., Migrating to Fortran 90, O’Reilly & Associates Inc., 1994, (389 pages), ISBN 1-56592-049-X;

•  Lignelet P., Fortran 90 : approche par la pratique, Éditions Studio Image

(série informatique), 1993, ISBN 2-909615-01-4;

•  Lignelet P., Manuel complet du langage Fortran 90 et Fortran 95, calcul intensif et génie logiciel, Col. Mesures physiques,Masson, 1996, (320 pages), ISBN 2-225-85229-4;

•  Lignelet P., Structures de données et leurs algorithmes avec Fortran 90 et Fortran 95, Masson, 1996, (360 pages), ISBN 2-225-85373-8;

•  Morgan and Schoenfelder, Programming in Fortran 90, Alfred Waller Ltd., 1993, ISBN 1-872474-06-3;

•  Metcalf M., Reid J.,

•  Fortran 90 explained, Science Publications, Oxford, 1994, (294 pages), ISBN 0-19-853772-7, Traduction française par Pichon B. et Caillat M., Fortran 90 : les concepts fondamentaux, Éditions AFNOR, 1993, ISBN

2-12-486513-7 ;

•  Fortran 95/2003 explained, Oxford University Press, 2004, (416 pages),

ISBN 0-19-852693-8;

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               16 / 314

Introduction

bibliographie

•  Olagnon Michel, Traitement de données numériques avec Fortran 90, Masson, 1996, (364 pages), ISBN 2-225-85259-6

•  Redwine Cooper, Upgrading to Fortran 90, Springer, 1995, ISBN 0-387-97995-6;

•  International Standard ISO/IEC 1539-1:1997(E) Information technology - Progr.

languages - Fortran - Part1 : Base language. Disponible auprès de l’AFNOR.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               17 / 314

Introduction

documentation

•  Documentation IBM/Blue Gene/Q :

•  Getting Started with XL Fortran

•  Compiler Reference

•  Language Reference

•  Optimization and programming guide disponibles sur le serveur Web IDRIS à l’adresse :

•  Documentation générale

•  Supports de cours Fortran 95 IDRIS : , choix « Supports de cours » puis « Fortran »

•  The Fortran Company :

•  État d’avancement de l’intégration de la norme Fortran 2003 :

•  d’avancement de l’intégration de la norme Fortran 2008 :

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

18 / 314

Généralités

1    Introduction

2    Généralités

Structure d’un programme

Compilation, édition des liens, exécution Éléments syntaxiques

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules

9    Interface générique

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

19 / 314

Généralités

et gestion de zones dynamiques

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

20 / 314

Généralités

Structure d’un programme

Structure d’un programme

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

21 / 314

Généralités

Compilation, édition des liens, exécution

Compilation, édition des liens, exécution

•  Le compilateur crée pour chaque fichier source :

•  un fichier objet de même nom suffixé par .o,

•  autant de fichiers nom_module.mod qu’il y a de modules (sur IBM RS/SP6, la commande what permet de savoir, entre autres, de quel fichier source ils sont issus).

•  Si un module fait appel (USE) à d’autres modules, ces derniers doivent avoir été précédemment compilés.

————————————————————————————–

1   Compilation préalable des sources contenant les modules :

f90 -c mod1.f90 mod2.f90

2   Compil./link de prog.f90 utilisant ces modules :

f90 prog.f90 mod1.o mod2.o

les fichiers .mod (contenant la partie descripteur) sont automatiquement trouvés s’ils se trouvent dans le répertoire courant ou dans celui du source. L’option -I permet de spécifier d’autres répertoires de recherche prioritaires.

3   Exécution : a.out

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               22 / 314


Généralités

Éléments syntaxiques

Le « format fixe »

Le « format fixe » de Fortran correspond à l’ancien format du Fortran 77 avec deux extensions :

•  plusieurs instructions possibles sur une même ligne ;

•  nouvelle forme de commentaire introduite par le caractère « ! ».

Son principal intérêt est d’assurer la compatibilité avec Fortran 77. C’est un aspect obsolète du langage!

Structure d’une ligne en « format fixe » :

•  zone étiquette (colonnes 1 à 5)

•  zone instruction (colonnes 7 à 72)

•  colonne suite (colonne 6)

Les lignes qui commencent par C, c, * ou ! en colonne 1 sont des commentaires.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               27 / 314

Généralités

Éléments syntaxiques

Les déclarations

Déclarer une variable permet notamment de lui attribuer un type. De même que l’ancien Fortran un type par défaut est appliqué aux variables non déclarées. Il est vivement recommandé de spécifier l’instruction IMPLICIT NONE en tête de toute unité de programme pour être dans l’obligation de les déclarer. La syntaxe d’une déclaration est la suivante :

type[, liste_attributs :: ] liste_identificateurs

Liste des différents types :

•  real

•  integer

•  double precision

•  complex

•  character

•  logical

•  type  

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               28 / 314

Généralités

Éléments syntaxiques

Différents attributs :

parameter constante symbolique dimension taille d’un tableau allocatable objet dynamique pointer objet défini comme pointeur target objet accessible par pointeur (

save                                            objet statique

intent      vocation d’un argument muet optional    argument muet facultatif

public ou private           visibilité d’un objet défini dans external ou intrinsic nature d’une procédure

cible)

un module

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

29 / 314



                                                                                             Généralités            Éléments syntaxiques

Typage des données : paramètre KIND (nouveautés norme 2008)

La norme 2008 a défini un module (ISO_FORTRAN_ENV) renfermant diverses constantes symboliques facilitant la déclaration des données de type intrinsèque (précision du gabarit mémoire, variantes disponibles, ) :

1   INTEGER_KINDS, REAL_KINDS, LOGICAL_KINDS sont des tableaux contenant les valeurs des différentes variantes disponibles pour les types INTEGER, REAL et LOGICAL respectivement;

2   INT8, INT16, INT32 et INT64 permettent de préciser le gabarit (8, 16, 32, 64 bits) d’un entier;

3   REAL32, REAL64 et REAL128 permettent de préciser le gabarit (32, 64, 128 bits) d’un réel;

4   NUMERIC_STORAGE_SIZE est la valeur en bits d’une donnée déclarée de type INTEGER, REAL ou LOGICAL par défaut, c-à-d sans spécification du paramètre KIND (32 généralement);

5   CHARACTER_STORAGE_SIZE est la valeur en bits d’une donnée déclarée de type CHARACTER (8 généralement).

Remarques

•  toute unité de programme devra comporter l’instruction « use ISO_FORTRAN_ENV » pour accéder à ces constantes;

•  dans le cas où la taille demandée n’est pas disponible pour le compilateur utilisé, la constante correspondante renfermera la valeur -2 si une taille supérieure est disponible, -1


sinon. Exemple

use ISO_FORTRAN_ENV real(kind=REAL64) :: x ! réel sur 64 bits. integer(kind=INT64) :: i ! entier sur 64 bits.

Patrick Corde Hervé Delouis ( )                                                       Langage Fortran(Avancé)


26 juin 2017                  33 / 314


Généralités

Éléments syntaxiques

Fonctions intrinsèquesSELECTED_INT_KIND,SELECTED_REAL_KIND

Elles ont pour prototype :

SELECTED_INT_KIND(r), SELECTED_REAL_KIND(p,r)

La première reçoit un nombre entier r en argument et retourne une valeur qui correspond au sous-type permettant de représenter les entiers n tels que :

?10r < n < 10r

Elle retourne -1 si aucun sous-type ne répond à la demande.

La deuxième admet deux arguments p et r indiquant respectivement la précision

(nombre de chiffres décimaux significatifs) et l’étendue (range) désirées. Elle retourne un entier (kind) qui correspond au sous-type permettant de représenter les réels x répondant à la demande avec :

10?r <| x |< 10r

Les arguments p et r sont optionnels, toutefois l’un des deux doit obligatoirement être fourni.

Cette fonction retourne -1 si la précision demandée n’est pas disponible, -2 si c’est l’étendue et -3 si ni l’une ni l’autre ne le sont.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               37 / 314

Généralités

Éléments syntaxiques

Schéma de représentation des nombres réels pour une variante donnée :

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               38 / 314

Généralités

Éléments syntaxiques

Fonctions intrinsèquesRANGEetPRECISION

Pour le sous-type de l’argument entier ou réel fourni, la fonction RANGE retourne la valeur entière maximale de l’exposant décimal r telle que tout entier ou réel satisfaisant :

|entier| < 10r

10?r < |réel| < 10r

est représentable.

La fonction PRECISION retourne la précision décimale (nombre maximum de chiffres significatifs décimaux — mantisse) pour le sous-type de l’argument réel fourni.

Exemples

Cray C90

Machines IEEE

range(1_4)

9

9

range(1_8)

18

18

range(1.0)

2465

37

precision(1.0)

13

6

range(1.d0)

2465

307

precision(1.d0)

28

15

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               40 / 314

Types dérivés

1    Introduction

2    Généralités

3    Types dérivés

Définition et déclaration de structures

Initialisation (constructeur de structure)

Constructeur de structure : norme 2003

Symbole % d’accès à un champ

Types dérivés et procédures

Types dérivés et entrées/sorties

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

41 / 314

Types dérivés

et gestion de zones dynamiques

9   Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

42 / 314


Types dérivés

Initialisation (constructeur de structure)

Constructeur de structure : norme 2003

Remarques

•  pour une composante comportant l’attribut pointer, c’est une association (au sens du symbole « => ») qui s’effectuera avec l’argument précisé au niveau du constructeur. On pourra indiquer la fonction NULL pour forcer la composante à l’état nul de façon explicite;

•  pour une composante comportant l’attribut allocatable, l’argument précisé au niveau du constructeur devra être de même type et de même rang. S’il a l’attribut allocatable, il peut être ou non alloué. Comme pour une composante pointer, on pourra préciser la fonction NULL mais sans argument : la composante sera alors dans l’état "non alloué".

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               46 / 314

Types dérivés

Symbole % d’accès à un champ

Symbole « % » d’accès à un champ

Le symbole « % » permet d’accéder à un champ d’une structure de donnée. Voici quelques exemples :

•  TC? tableau de structures de données de type dérivé COULEUR;

•  TC(2) et TABRVB(3)? structures de type COULEUR;

•  TC(1)%nom? champ nom ("Gris souris") de TC(1);

•  TC(1)%code_rvb? tableau de 3 entiers contenant les composantes RVB de la teinte "Gris souris";

•  TC(2)%code_rvb(2)? entier : composante verte du "Gris anthracite";

•  TC%code_rvb(2)? tableau de 5 entiers : composantes vertes ;

•  TC%code_rvb?INCORRECT!! car au moins une des deux entités encadrant le symbole % doit être un scalaire (rang nul) sachant qu’une structure est considérée comme un scalaire. Dans ce cas, TC et code_rvb sont des tableaux de rang 1.

Remarque

•  dans le cas où la partie gauche du symbole % est un tableau, l’opérande de droite ne doit pas avoir l’attribut pointer ni allocatable!

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               47 / 314


Types dérivés

Types dérivés et procédures

Types dérivés et procédures

Une structure de données peut être transmise en argument d’une procédure et une fonction peut retourner un résultat de type dérivé.

Si le type dérivé n’est pas « visible » (par use association depuis un module ou par host association depuis la procédure hôte), il doit être défini à la fois (situation à éviter) dans l’appelé et l’appelant. Les deux définitions doivent alors :

•  posséder toutes les deux l’attribut SEQUENCE? stockage des champs avec même ordre et mêmes alignements en mémoire ;

•  être identiques. Le nom du type et celui de la structure peuvent différer mais pas le nom et la nature des champs.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               49 / 314

Types dérivés

Types dérivés et entrées/sorties

Remarques

•  chaque champ peut être constitué d’éléments de type intrinsèque (real, integer, logical, character, etc.) ou d’un autre type dérivé imbriqué;

•  l’attribut PARAMETER est interdit au niveau d’un champ ;

•  l’initialisation d’un champ à la définition du type n’est possible que depuis la norme 95. Un objet d’un tel type, à moins qu’il soit initialisé à sa déclaration, ne reçoit pas implicitement l’attribut SAVE. Il ne peut pas figurer dans un COMMON;

•  la norme 90/95 interdit l’attribut ALLOCATABLE au niveau d’un champ (valide depuis la norme 2003);

•  un objet de type dérivé est considéré comme un scalaire mais :

•  un champ peut avoir l’attribut DIMENSION;

•  on peut construire des tableaux de structures de données.

•  l’attribut SEQUENCE pour un type dérivé est obligatoire si une structure de ce type :

•  est passée en argument d’une procédure externe au sein de laquelle une redéfinition du type est nécessaire;

•  fait partie d’un COMMON.

•  un champ peut avoir l’attribut POINTER mais pasTARGET.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               53 / 314

Types dérivés

Types dérivés et entrées/sorties

Remarques

L’attribut pointer appliqué au champ d’une structure permet :

•  la déclaration de tableaux de pointeurs via un tableau de structures contenant un champ unique ayant l’attribut pointer; cf. paragraphe « Tableaux de pointeurs » du chapitre 7 page 151;

•  la gestion de listes chaînées basées sur des types dérivés tels :

type cell real,dimension(4) :: x character(len=10) :: str type(cell),pointer :: p

end type cell

cf. l’exemple du chap. 7 page 155 et le corrigé de l’exercice 12 en annexe B;

•  l’allocation dynamique de mémoire appliquée à un champ de structure.

À noter : lors de l’affectation entre 2 structures (de même type), le compilateur réalise effectivement des affectations entre les composantes. Pour celles ayant l’attribut pointer cela revient à réaliser une association.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               54 / 314


Programmation structurée

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

Introduction

Boucles DO

Le bloc SELECT-CASE

La structure block

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules

9    Interface générique

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

55 / 314

Programmation structurée

et gestion de zones dynamiques

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

56 / 314


Extensions tableaux

onstructeur, section, taille, )

e et profil implicites) nt d’une procédure

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

Définitions (rang, profil, étendue, )

Manipulations de tableaux (conformance, c

Initialisation de tableaux

Sections de tableaux

Sections irrégulières

Tableau en argument d’une procédure (taill Section de tableau non contiguë en argume

Fonctions intrinsèques tableaux

Instruction et bloc WHERE

Expressions d’initialisation

Exemples d’expressions tableaux

6 Gestion mémoire

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

68 / 314

Extensions tableaux

et gestion de zones dynamiques

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

69 / 314



                                                                                 Extensions tableaux             Sections de tableaux

Sections de tableaux

Il est possible de faire référence à une partie d’un tableau appelée section de tableau ou sous-tableau. Cette partie de tableau est également un tableau. De plus le tableau, dans son intégralité, est considéré comme le tableau parent de la partie définie. Le rang d’une section de tableau est inférieur ou égal à celui du tableau parent. Il sera inférieur d’autant d’indices qu’il y en a de fixés.

Il existe deux catégories de sections : les sections dites régulières et les sections irrégulières.

Extensions tableaux

Sections de tableaux

INTEGER, DIMENSION(5,9) :: T

x

x

x

x

x

x

x

x

x

x

? T(1:2,3:7) (rang=2, profil=(/ 2,5 /))

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

x

? T(1:5:2,:) (rang=2, profil=(/ 3,9 /))

                                                ? T(2:4,4) (rang=1, profil=(/ 3 /))

T(i,j)

rang=0

Scalaire

T(i:i,j:j)

rang=2

profil=(/ 1,1 /)

Tableau dégénéré

T(2:,3)

rang=1

profil=(/ 4 /)

Vecteur

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017                    76 / 314

On désigne par section régulière un ensemble d’éléments dont les indices forment une progression arithmétique. Pour définir une telle section on utilise la notation par triplet de la forme « val_init:val_fin:pas » équivalent à une pseudo-boucle.

Par défaut, la valeur du pas est 1 et les valeurs de val_init et val_fin sont les limites définies au niveau de la déclaration du tableau parent. La notation dégénérée sous la


forme d’un simple « : » correspond à l’étendue de la dimension considérée.

Exemple

integer, dimension(10) :: a = (/ (i, i=1,10) /) integer, dimension(6) :: b integer, dimension(3) :: c

c(:) = a(3:10:3) ! <== "Gather" b(1:6:2) = c(:) ! <== "Scatter"

Patrick Corde Hervé Delouis ( )                                                    Langage Fortran(Avancé)


26 juin 2017                  75 / 314



Extensions tableaux

Section de tableau non contiguë en argument d’une procédure

Section de tableau non contiguë en argument d’une procédure

Une section de tableau peut être passée en argument d’une procédure.

Attention :

si elle constitue un ensemble de valeurs non contiguës en mémoire, le compilateur peut être amené à copier au préalable cette section dans un tableau d’éléments contigus passé à la procédure, puis en fin de traitement le recopier dans la section initiale

?Dégradation possible des performances !

En fait, cette copie (copy in–copy out) n’a pas lieu si les conditions suivantes sont réalisées :

•  la section passée est régulière,

•  l’argument muet correspondant est à profil implicite (ce qui nécessite que l’interface soit explicite).

C’est le cas de l’exemple suivant : le sous-programme sub1 reçoit en argument une section régulière non contiguë alors que le sous-programme sub2 reçoit le tableau dans sa totalité. Les temps d’exécutions sont analogues.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               82 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Interrogation (maxloc, lbound, shape, )

SHAPE(source)

retourne le profil du tableau passé en argument.

SIZE(array[,dim])

retourne la taille (ou l’étendue de la dimension indiquée via dim) du tableau passé en argument.

UBOUND(array[,dim]), LBOUND(array[,dim])

retournent les bornes supérieures/inférieures de chacune des dimensions (ou seulement de celle indiquée via dim) du tableau passé en argument.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               85 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

integer, dimension(-2:27,0:49) :: t

?

SHAPE(t)

SIZE(t)                             ?

?

SIZE(t,dim=1)

SIZE(SHAPE(t))              ?

UBOUND(t)                      ?

?

UBOUND(t(:,:))             ?

UBOUND(t,dim=2) ?

?

LBOUND(t)

LBOUND(t(:,:))              ?

LBOUND(t,dim=1) ?

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

86 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

integer, dimension(0:2,-1:2) :: A

MAXLOC(array=A, .5) ? (/ 2,2 /)

? (/ 3,3 /)

MINLOC(array=A, .5)

0     -5           8 -3 !  MINLOC(array=A, mask=A>8 ) ? [ 0,0 ]

A= 3            4 -1          2           ?MAXLOC(A, dim=2)                                       ? (/ 3,2,3 /)

1     5 6 -4    MAXLOC(A, dim=1) ? (/ 2,3,1,2 /)



? (/ 1,2,1 /)

MAXLOC(A, dim=2, mask=A<5)

MAXLOC(A, dim=1, mask=A<5) ? (/ 2,2,2,2 /)

Note :

• si array et mask sont de rang n et de profil (/d1,d2, ,dn/) et si dim=i est spécifié, le tableau retourné par ce type de fonctions sera de rang n-1 et de profil

(/d1,d2, ,di?1,di+1, ,dn/)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               88 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de réduction

Selon que DIM est absent ou présent, toutes ces fonctions retournent soit un scalaire soit un tableau de rang n-1 en désignant par n le rang du tableau passé en premier argument.

ALL(mask[,dim])

DIM=i? la fonction travaille globalement sur cet indice (c.-à-d. un vecteur) pour chaque valeur fixée dans les autres dimensions.

1    3 5          0 3 5    T F F

A=                              ; B=                                ?A/=B =

2    4 6          7 4 8    T F T

•  Réduction globale : ALL(A.NE.B) ? .false.

•  Réduction par colonne :

ALL(A.NE.B, dim=1) ? (/ .true.,.false.,.false. /)

•  Réduction par ligne :

ALL(A.NE.B, dim=2) ? (/ .false.,.false. /)

•  Comparaison globale de deux tableaux : if (ALL(A==B))

•  Test de conformance (entre tableaux de même rang) :

                                if (ALL(shape(A) == shape(B)))                                                                                            

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               89 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de réduction

ANY(mask[,dim])

1    3 5          0 3 5    T F F

A=                              ; B=                                ?A/=B =

2    4 6          7 4 8    T F T

•  Réduction globale : ANY(A/=B) ? .true.

•  Réduction par colonne :

ANY(A/=B, dim=1) ? (/ .true.,.false.,.true. /)

•  Réduction par ligne :

ANY(A/=B, dim=2) ? (/ .true.,.true. /)

•  Comparaison globale de deux tableaux : if (ANY(A/=B))

•  Test de non conformance (entre tableaux de même rang) :

if (ANY(shape(A) /= shape(B)))

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

90 / 314


Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de réduction

COUNT(mask[,dim])

1   COUNT( (/ .true.,.false.,.true. /) ) ? 2

                                     1 3 5                              0 3 5                                          T F F

2   A=      ; B=    ?A/=B =

                                     2 4 6                              7 4 8                                          T F T

•   Décompte global des valeurs vraies :

COUNT(A/=B) ? 3

•   Décompte par colonne des valeurs vraies :

COUNT(A/=B,dim=1) ? (/ 2,0,1 /)

•   Décompte par ligne des valeurs vraies :

COUNT(A/=B,dim=2) ? (/ 1,2 /)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

91 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de réduction

MAXVAL(array,dim[,mask]); MAXVAL(array[,mask])

MINVAL(array,dim[,mask]); MINVAL(array[,mask])

1   MINVAL( (/ 1,4,9 /) ) ? 1 , MAXVAL( (/ 1,4,9 /) ) ? 9

MINVAL(A,dim=1)                              ?             (/ 1,3,5 /)

MINVAL(A,dim=2)                              ?            (/ 1,2 /)

MAXVAL(A,dim=1)                             ?             (/ 2,4,6 /)

MAXVAL(A,dim=2)                                  ?            (/ 5,6 /)

1    3 5          ?

2   A=

2    4 6          MINVAL(A,dim=1,mask=A>1) ?    (/ 2,3,5 /)

MINVAL(A,dim=2,mask=A>3) ?                 (/ 5,4 /)

MAXVAL(A,dim=1,mask=A<6) ?                  (/ 2,4,5 /)

?            (/ 1,2 /)

MAXVAL(A,dim=2,mask=A<3)

Note :

• si le masque est partout faux, MINVAL retourne la plus grande valeur représentable (dans le type associé à A) et MAXVAL la plus petite.      

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               92 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de réduction

PRODUCT(array,dim[,mask]) ; PRODUCT(array[,mask])

SUM(array,dim[,mask])                      ; SUM(array[,mask])

1    PRODUCT( (/ 2,5,-6 /) ) ? -60, SUM( (/ 2,5,-6 /) ) ? 1

PRODUCT(A,dim=1)                              ?             (/ 2,12,30 /)

PRODUCT(A,dim=2)                              ?            (/ 15,48 /)

SUM(A,dim=1)                                       ?            (/ 3,7,11 /)

SUM(A,dim=2)                                           ?            (/ 9,12 /)

1    3 5           

2    A=   ?

2    4 6            PRODUCT(A,dim=1,mask=A>4) ? (/ 1,1,30 /)

PRODUCT(A,dim=2,mask=A>3) ?                 (/ 5,24 /)

SUM(A,dim=1,mask=A>5)                   ?             (/ 0,0,6 /)

?            (/ 1,0 /)

SUM(A,dim=2,mask=A<2)

Note :

• si le masque est partout faux, ces fonctions retournent l’élément neutre de l’opération concernée.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               93 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de multiplication

DOT_PRODUCT(vector_a,vector_b)

MATMUL(matrix_a,matrix_b)

DOT_PRODUCT retourne le produit scalaire des deux vecteurs passés en argument, MATMUL effectue le produit matriciel de deux matrices ou d’une matrice et d’un vecteur passés en argument.

1   DOT_PRODUCT( (/ 2,-3,-1 /), (/ 6,3,3 /) ) = 0

                                         ? 3 -6 -1 ?                         ? 2 ?                                              ? 29 ?

2   A =? 2           3          1 ?; V =? -4 ??MATMUL(A,V) =? -7 ?

                                         -1 -2          4                            1                                                   10

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               94 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de multiplication

Les deux fonctions DOT_PRODUCT et MATMUL admettent des vecteurs et/ou matrices de type logique en argument.

DOT_PRODUCT(v1,v2)

v1 de type entier ou réel          ? sum(v1*v2) v1 de type complexe            ? sum(conjg(v1)*v2) v1 et v2 de type logique    ? any(.v2)

c = MATMUL(a,b)

Si profil(a)=(/ n,p /) ? profil(c) = (/ n,q /) et profil(b)=(/ p,q /)       ci,j=sum(a(i,:)*b(:,j))

Si profil(a)=(/ p /) ? profil(c) = (/ q /) et profil(b)=(/ p,q /)       cj=sum(a*b(:,j))

Si profil(a)=(/ n,p /) ? profil(c) = (/ n /) et profil(b)=(/ p /)       ci=sum(a(i,:)*b)

Si a et b de type logique              ? On remplace sum par any et * par .and. dans les formules précédentes 

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               95 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de construction/transformation

RESHAPE(source,shape[,pad][,order])

Cette fonction permet de construire un tableau d’un profil donné à partir d’éléments d’un autre tableau.

1    RESHAPE( (/ (i,i=1,6) /), (/ 2,3 /) )

1    3 5

2    4 6

?

2    RESHAPE( (/ ((i==j,i=1,4),j=1,3) /), (/ 4,4 /), & (/ .true., .true., .true., .true. /) )

? T F F T ?

F T F T

?                              ?

? F F T T ?

F F F T

?

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               96 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

ii

DIM=1DIM=2

CSHIFT  sur un tableau de rang 3  M(i, j, k)

Note :

• si array est de rang n et de profil (/d1,d2, ,dn/), l’argument shift doit être un scalaire ou un tableau d’entiers de rang n-1 et de profil (/d1,d2, ,ddim?1,ddim+1, ,dn/).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                      26 juin 2017               99 / 314

Extensions tableaux

Fonctions intrinsèques ta

bleaux

Fonctions de construction/transformation

? a b c d ?

e f g h

         Soit M le tableau ?                                ?

? i j k l ? m n o p

CSHIFT( array=M, shift=-1 )

? m n o p ?

a b c d

?                              ?

? e f g h ? i j k l

?

CSHIFT( array=M, shift=(/ 2,-2,-1,0 /), dim=2

? c d a b ?

g h e f

?                              ?

? l i j k ? m n o p

?

)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

100 / 314

Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de construction/transformation

EOSHIFT(array,shift[,boundary][,dim])

Cette fonction permet d’effectuer des décalages sur les éléments d’un tableau dans une dimension (DIM) donnée avec possibilité de remplacer ceux perdus (End Off) à la "frontière" (boundary) par des éléments de remplissage.

SHIFT > 0          ?        décalage vers les indices décroissants

SHIFT < 0          ?        décalage vers les indices croissants

Par défaut : DIM=1

Si, lors d’un remplacement, aucun élément de remplissage (boundary) n’est disponible celui par défaut est utilisé. Il est fonction du type des éléments du tableau traité.

                                                                       Type du tableau         Valeur par défaut

INTEGER

0

REAL

0.0

COMPLEX

(0.0,0.0)

LOGICAL

.false.

CHARACTER(len)

len blancs

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              102 / 314


Extensions tableaux

Fonctions intrinsèques tableaux

Fonctions de construction/transformation

Notes :

•  pour linéariser une matrice : PACK( a, . );

•  à défaut de l’argument VECTOR, le résultat est un vecteur de taille égale au nombre d’éléments vrais du masque (COUNT(MASK)).

Si VECTOR est présent, le vecteur résultat aura la même taille que lui (et sera complété en "piochant" dans VECTOR), ce qui peut être utile pour assurer la conformance d’une affectation. Le nombre d’éléments de VECTOR doit être égal ou supérieur au nombre d’éléments vrais du masque.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              105 / 314


Extensions tableaux

Instruction et bloc WHERE

Instruction et bloc WHERE

Ce qui est équivalent à :

do i = 1,10 if (a(i) > 0.) then a(i) = log(a(i)) else a(i) = 1.

end if

end do

Remarques

WHERE (expression_logique_tableau) instruction

•  Lorsque bloc2 est absent et que bloc1 se résume à une seule instruction, on peut utiliser la forme simplifiée :

Exemple?WHERE(a>0.0) a = sqrt(a)

•  Dans l’exemple suivant : WHERE(a>0.) a = a - sum(a) , la fonction sum est évaluée comme la somme de tous les éléments de a, car sum n’est pas une fonction élémentaire (fonction que l’on peut appliquer séparément à tous les éléments d’un tableau).

Cependant l’affectation n’est effectuée que pour les éléments positifs de a.                     

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              112 / 314

Extensions tableaux

Instruction et bloc WHERE

Instruction et bloc WHERE

•  Considérons l’exemple suivant :

WHERE(a>0.) b = a/sum(sqrt(a))

La règle veut que les fonctions élémentaires (ici sqrt) apparaissant en argument d’une fonction non élémentaire (ici sum) ne soient pas soumises au masque. L’expression sum(sqrt(a)) sera donc calculée sur tous les éléments de a. Cela provoquera bien sûr une erreur si l’une au moins des valeurs de a est négative.

•  Lors de l’exécution d’une instruction ou d’un bloc WHERE le masque est évalué avant que les instructions d’affectation ne soient exécutées. Donc si celles-ci modifient la valeur du masque, cela n’aura aucune incidence sur le déroulement de l’instruction ou du bloc WHERE.

•  On ne peut imbriquer des blocs WHERE.

Norme 95 : il est possible d’imbriquer des blocs WHERE qui peuvent être étiquetés de la même façon que le bloc select ou la boucle DO par exemple. De plus, le bloc WHERE peut contenir plusieurs clauses ELSEWHERE avec masque logique (sauf le dernier).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              113 / 314

Extensions tableaux

Expressions d’initialisation

Expressions d’initialisation

Une expression d’initialisation (« initialization-expression ») doit être formée à l’aide de constantes ou d’expressions constantes. Ce type d’expression est utilisé lors d’une déclaration et peut être construite à l’aide d’éléments comme indiqués dans les exemples suivant :

•  constructeur de vecteur (avec boucles implicites) :

integer i

integer, dimension(10) :: t1=(/ (i*2, i=1,10) /)

•  constructeur de structure : type(couleur) :: c2=couleur("Vert", (/ 0.,1.,0. /))

•  fonctions intrinsèques élémentaires :

integer, parameter       :: n=12**4 integer(kind=2)         :: l=int(n, kind=2)

character(len=*), parameter :: str = "CNRS/IDRIS"

                      integer                                                                                         :: k=index(str, "IDRIS")

                    real                                                                                         :: x=real(n)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              114 / 314


Extensions tableaux

Expressions d’initialisation

•  fonctions intrinsèques d’interrogation (LBOUND, UBOUND, SHAPE, SIZE, BIT_SIZE,

KIND, LEN, DIGITS, EPSILON, HUGE, TINY, RANGE, RADIX, MAXEXPONENT, MINEXPONENT) :

real, dimension(10,20) :: a

integer               :: d=size(a,1)*4 integer :: n=kind(0.D0)

•  fonctions de transformation (REPEAT, RESHAPE, TRIM, SELECTED_INT_KIND, SELECTED_REAL_KIND, TRANSFER, NULL, ) :

integer i

integer, dimension(4,2) :: t = & reshape( source=[ (i,i=1,8) ], shape=shape(t) ) real, pointer :: p=>null()

Remarque

•  La notation « [] » utilisée dans l’exemple précédent a été introduite par la norme 2003 pour l’écriture du constructeur de vecteur. Il est bien entendu que les caractères habituels « (/, /) » sont toujours valides.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              115 / 314

Extensions tableaux

Exemples d’expressions tableaux

Exemples d’expressions tableaux

N!

PRODUCT((/ (k,k=2,N) /))

X

ai

i

SUM(A)

X

ai cos xi

i

SUM(A*cos(X))

X

ai cos xi

|ai|<0.01

SUM(A*cos(X), mask=ABS(A)<0.01)

XY

aij

j         i

SUM(PRODUCT(A, dim=1))

YX

aij

i         j

PRODUCT(SUM(A, dim=2))

       X                2

(xi ? x)

i

SUM((X - SUM(X)/SIZE(X))**2)

Linéarisation d’une matrice M

PACK(M, .)

3eligne de M

M(3,:)

2ecolonne de M

M(:,2)

X X

Mij 1?i?3 2?j?4

SUM(M(1:3,2:4))

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

116 / 314

Extensions tableaux

Exemples d’expressions tableaux

Exemples d’expressions tableaux

Trace : somme éléments diagonaux de M

SUM(M, mask=reshape( &

source=(/ ((i==j,i=1,n),j=1,n) /),&

shape=shape(M)))

Valeur max. matrice triangulaire inférieure de M

MAXVAL(M, mask=reshape( & source=(/ ((i>=j,i=1,n),j=1,n) /),&

shape=shape(M)))

Dérivée selon les lignes (domaine cylindrique)

( CSHIFT(M, shift= 1, dim=2) - &

CSHIFT(M, shift=-1, dim=2) ) / 2.

Décompte des éléments positifs

COUNT(M > 0.)

X kMk1 = maxj          |mij|

i

MAXVAL(SUM(ABS(M), dim=1))

X kMk? = maxi          |mij|

j

MAXVAL(SUM(ABS(M), dim=2))

Produit matriciel : M1.M2T

MATMUL(M1, TRANSPOSE(M2))

Produit scalaire : V~.W~

DOT_PRODUCT(V, W)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              117 / 314

Gestion mémoire

fil différé

003 rme 2003

norme 2003 rme 2003

norme 2003

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

Expressions de spécification

Tableaux automatiques

Tableaux dynamiques ALLOCATABLE, pro

Argument muet ALLOCATABLE : norme 2

Composante allouable d’un type dérivé : no Allocation d’un scalaire ALLOCATABLE : Allocation/réallocation via l’affectation : no Procédure MOVE_ALLOC de réallocation :

7    Pointeurs

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

118 / 314

                                                                                     Gestion mémoire             Expressions de spécification

Expressions de spécification

Une expression de spécification (« specification-expression ») est une expression formée au moyen de constantes et de variables dont les valeurs peuvent être déterminées à l’entrée d’une procédure avant toute exécution d’instructions exécutables. C’est une expression scalaire entière.

Ces variables peuvent être des arguments muets, définies dans un COMMON ou bien accessibles via « use ou host-association ».

Des fonctions intrinsèques telles que LBOUND, UBOUND, SHAPE, SIZE, BIT_SIZE, KIND,

Gestion mémoire

8 Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

119 / 314

LEN, DIGITS, EPSILON, HUGE, TINY, RANGE, RADIX, MAXEXPONENT, MINEXPONENT peuvent apparaître au sein de ces expressions.

Ce type d’expression est employé pour préciser les dimensions de tableaux et les longueurs de chaînes de caractères comme dans l’exemple suivant :

Exemple

subroutine sp( n, m, c, ) ! Déclarations des arguments integer n, m character(len=*) c

! Déclarations des variables locales real, dimension(n*m) :: vec character(len=len(c)) :: chaine

end subroutine sp

120 / 314


Gestion mémoire

Tableaux dynamiques ALLOCATABLE, profil différé

Tableaux dynamiquesALLOCATABLE, profil différé : remarques

•  attention : en cas de problème au moment de l’allocation et en l’absence du paramètre STAT=etat, l’exécution du programme s’arrête automatiquement avec un message d’erreur (traceback); s’il est présent, l’exécution continue en séquence et c’est à vous de tester la valeur retournée dans la variable entière etat qui est différente de zéro en cas de problème;

•  il n’est pas possible de réallouer un tableau déjà alloué. Il devra être libéré auparavant;

•  un tableau local alloué dynamiquement dans une unité de programme a un état indéterminé à la sortie (RETURN/END) de cette unité sauf dans les cas suivants :

•  l’attribut SAVE a été spécifié pour ce tableau;

•  une autre unité de progr. encore active a visibilité par use association sur ce tableau déclaré dans un module;

•  cette unité de progr. est interne. De ce fait (host association), l’unité hôte peut encore y accéder.

Norme 95 : ceux restant à l’état indéterminé sont alors automatiquement libérés;

•  un tableau dynamique peut avoir l’attribut TARGET; sa libération (deallocate) doit obligatoirement se faire en spécifiant ce tableau et en aucun cas un pointeur intermédiaire lui étant associé ;

•  un tableau dynamique peut être transmis en argument. Selon les normes 90/95 l’argument muet correspondant ne doit pas avoir l’attribut ALLOCATABLE : il devra être alloué avant l’appel et c’est un tableau classique qui sera alors récupéré dans la procédure appelée.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              123 / 314


Gestion mémoire

Allocation/réallocation via l’affectation : norme 2003

À noter que cette possibilité de réallocation dynamique facilite la gestion des chaînes dynamiques ainsi que le respect de la contrainte de conformance lors d’une affectation de tableaux. Ainsi par exemple :

real, ALLOCATABLE, dimension(:) :: x

!--allocate( x(count( masque )) ) <--- Devient inutile !

x = pack( tableau, masque )

Le tableau x est automatiquement alloué/réalloué avec le bon profil sans que l’on ait à se préoccuper du nombre d’éléments vrais de masque.

Note :

•  ce processus d’allocation/réallocation automatique peut être inhibé en mentionnant explicitement tout ou partie de l’objet :

                                   NAME(:)                                                               = "chaîne_de_caractères"

x(1:count( masque )) = pack( tableau, masque )

À gauche de l’affectation, la présence du caractère « : » signifie qu’on fait référence à un sous-ensemble d’une entité (NAME ou x) qui doit exister et donc être déjà allouée;

•  avec le compilateur « ifort » d’INTEL il est nécessaire de positionner l’option « -assume realloc_lhs » pour bénéficier de ce mécanisme d’allocation/réallocation automatique.    

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              129 / 314

Gestion mémoire

Procédure MOVE_ALLOC de réallocation : norme 2003

ProcédureMOVE_ALLOCde réallocation : norme 2003

MOVE_ALLOC(FROM, TO)

Ce sous-programme permet de transférer une allocation d’un objet allouable à un autre dans le but , par exemple, d’étendre un objet déjà alloué.

•  FROM fait référence à une entité allouable de n’importe quel type/rang;

•  TO fait référence à une entité allouable de type compatible avec FROM et de même rang;

En retour de ce sous-programme, le tableau allouable TO désigne le tableau allouable FROM; la zone mémoire préalablement désignée par TO est désallouée.

En fait, c’est un moyen permettant de vider le descripteur de FROM après l’avoir recopié dans celui de TO.

•  si FROM n’est pas alloué en entrée, TO devient non alloué en sortie;

•  sinon, TO devient alloué avec les mêmes caractéristiques (type dynamique, paramètres de type, bornes de tableau, valeurs) que FROM avait en entrée ;

•  si TO a l’attribut TARGET, tout pointeur initialement associé à FROM devient associé à TO.          

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              130 / 314

Pointeurs

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

Définition, états d’un pointeur

Déclaration d’un pointeur

Symbole =>

Symbole = appliqué aux pointeurs

Allocation dynamique de mémoire

Imbrication de zones dynamiques

Fonction NULL() et instruction NULLIFY

Fonction intrinsèque ASSOCIATED

Situations à éviter

Déclaration de « tableaux de pointeurs »

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

133 / 314

Pointeurs

Passage d’un pointeur en argument de procédure

Passage d’une cible en argument de procédure

Pointeur, tableau à profil différé et COMMON Liste chaînée

8 Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

134 / 314

Pointeurs

Définition, états d’un pointeur

Définition, états d’un pointeur

En C, Pascal? variable contenant l’adresse d’objets En Fortran 90? alias d’objets

Tout pointeur Fortran a un état parmi les suivants :

1   Indéfini : à sa déclaration en tête de programme ;

2   Nul : alias d’aucun objet;

3   Associé : alias d’un objet (cible).

Note: pour ceux connaissant la notion de pointeur (type langage C), disons que le pointeur Fortran 90 est une abstraction de niveau supérieur en ce sens qu’il interdit la manipulation directe d’adresse. À chaque pointeur Fortran 90 est associé un

« descripteur interne » contenant les caractéristiques (type, rang, état, adresse de la cible, et même le pas d’adressage en cas de section régulière, etc ). Pour toute référence à ce pointeur, l’indirection est faite pour vous, d’où la notion d’« alias ». Comme nous allons le voir, ce niveau d’abstraction supérieur ne limite en rien (bien au contraire) les applications possibles.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              135 / 314


Pointeurs

Symbole =>

Symbole « => »

Cible : c’est un objet pointé. Cet objet devra avoir l’attribut target lors de sa déclaration :

integer, target :: i

Le symbole « => » sert à valoriser un pointeur. Il est binaire : op1 => op2

Pointeur

Cible

op1

N

op2

N

N

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

137 / 314


Pointeurs

Fonction intrinsèque ASSOCIATED

Fonction intrinsèque ASSOCIATED

Il n’est pas possible de comparer des pointeurs, c’est la fonction intrinsèque ASSOCIATED qui remplit ce rôle :

ASSOCIATED(pointer[, target])

ASSOCIATED(p)                ?        vrai si p est associé à une cible

?        faux si p est à l’état nul

ASSOCIATED(p1, p2)       ?         vrai si p1 et p2 sont alias de la même cible

?       faux sinon

ASSOCIATED(p1, c)         ?         vrai si p1 est alias de la cible c faux sinon

Remarques

•  l’argument optionnel TARGET peut être au choix une cible ou un pointeur;

•  le pointeur ne doit pas être dans l’état indéterminé;

•  si p1 et p2 sont à l’état nul alors ASSOCIATED(p1,p2) renvoie faux.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              145 / 314

Pointeurs

Situations à éviter

Remarques

•  un tableau ayant l’attribut ALLOCATABLE peut être la cible d’un pointeur ;

•  avant d’effectuer l’association, il faut bien prendre garde à ce que le tableau soit alloué.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              148 / 314

Pointeurs

Passage d’un pointeur en argument de procédure

Passage d’un pointeur en argument de procédure

1   L’argument muet n’a pas l’attribut pointer :

•   le pointeur doit être associé avant l’appel,

•   c’est l’adresse de la cible associée qui est passée,

•   l’interface peut être implicite ce qui permet l’appel d’une procédure Fortran 77. Attention : dans ce cas si la cible est une section régulière non contiguë, le compilateur transmet une copie contiguë, d’où un impact possible sur les performances (cf. chap. 5 page 83).

2   L’argument muet a l’attribut pointer :

•   le pointeur n’est pas nécessairement associé avant l’appel (avantage par rapport à allocatable),

•   c’est l’adresse du descripteur du pointeur qui est passée,

•   l’interface doit être explicite (pour que le compilateur sache que l’argument muet a l’attribut pointer),

•   si le pointeur passé est associé à un tableau avant l’appel, les bornes inférieures/supérieures de chacune de ses dimensions sont transmises à la procédure; elles peuvent alors être récupérées via les fonctions UBOUND/LBOUND.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              151 / 314

Pointeurs

Passage d’une cible en argument de procédure

Passage d’une cible en argument de procédure

L’attribut target peut être spécifié soit au niveau de l’argument d’appel, soit au niveau de l’argument muet, soit au niveau des deux. Il s’agit dans tous les cas d’un passage d’argument classique par adresse. Si l’argument muet a l’attribut target, l’interface doit être explicite.

1   Si l’argument muet est un scalaire ou un tableau à profil implicite avec l’attribut target et l’argument d’appel a également l’attribut target différent d’une section irrégulière alors :

•   tout pointeur associé à l’argument d’appel devient associé à l’argument muet,

•   au retour de la procédure, tout pointeur associé à l’argument muet reste associé à l’argument d’appel.

2   Si l’argument muet est un tableau à profil explicite ou à taille implicite avec l’attribut target et l’argument d’appel a également l’attribut target différent d’une section irrégulière alors :

•   le fait que tout pointeur associé à l’argument d’appel devienne associé à l’argument muet dépend du compilateur,

•   de même, au retour de la procédure, l’état d’un pointeur associé dans la procédure à l’argument muet est dépendant du compilateur.

3   Si l’argument muet à l’attribut target et l’argument d’appel n’a pas l’attribut target ou est une section irrégulière :

•   tout pointeur associé à l’argument muet dans la procédure devient indéfini au retour de la dite procédure.

Attention à l’utilisation des pointeurs globaux ou locaux permanents (save) éventuellement associés dans la procédure à cette cible dans le cas où le compilateur aurait dû faire une copie copy in–copy out de l’argument d’appel (cf. chapitre 5 page 83)

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              152 / 314


Interface de procédures et modules

AL

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules

Interface implicite : définition

Interface implicite : exemple

Arguments : attributs INTENT et OPTION

Passage d’arguments par mot-clé

Interface explicite : procédure interne

Interface explicite : 5 possibilités

Interface explicite : bloc interface

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

156 / 314

Interface de procédures et modules

Interface explicite : ses apports

Interface explicite : module et bloc interface

Interface explicite : module avec procédure

Cas d’interface explicite obligatoire

Argument de type procédural et bloc interface

9   Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

157 / 314

Interface de procédures et modules

Interface implicite : définition

Interface implicite : définition

L’interface de procédure est constituée des informations permettant la communication entre deux procédures. Principalement :

•  arguments d’appel (actual arguments),

•  arguments muets (dummy arguments),

•  instruction function ou subroutine.

En fortran 77

Compte tenu du principe de la compilation séparée des procédures et du passage des arguments par adresse, l’interface contient peu d’informations d’où une visibilité très réduite entre les deux procédures et donc des possibilités de contrôle de cohérence très limitées. On parle alors d’interface « implicite ».

En Fortran 90

Interface « implicite » par défaut entre deux procédures externes avec les mêmes problèmes ? cf. exemple ci-après montrant quelques erreurs classiques non détectées à la compilation.

L’exemple suivant fait appel à un sous-progr. externe maxmin pour calculer les valeurs max. et min. d’un vecteur vect de taille n et optionnellement le rang rg_max de la valeur max. avec mise-à-jour de la variable de contrôle ctl.      

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              158 / 314

Interface de procédures et modules

Arguments : attributs INTENT et OPTIONAL

Arguments : attributsINTENTetOPTIONAL

Un meilleur contrôle par le compilateur de la cohérence des arguments est possible en Fortran 90 à deux conditions :

1   améliorer la visibilité de la fonction appelée. Par exemple, en la définissant comme interne (CONTAINS). On parle alors d’interface « explicite ».

2   préciser la vocation des arguments muets de façon à pouvoir contrôler plus finement l’usage qui en est fait. Pour ce faire, Fortran 90 a prévu :

•   l’attribut INTENT d’un argument :

•   INTENT(in) : entrée seulement;

•   INTENT(out) : sortie seulement (dans la procédure, l’argument muet doit être défini avant toute référence à cet argument) ;

•   INTENT(inout) : entrée et sortie.

real, dimension(:), intent(in) :: vect

•   l’attribut OPTIONAL pour déclarer certains arguments comme optionnels et pouvoir tester leur présence éventuelle dans la liste des arguments d’appel (fonction intrinsèque PRESENT).

integer, optional, intent(out) :: rg_max . . . . . if ( present(rg_max) ) then

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              160 / 314

Interface de procédures et modules

Arguments : attributs INTENT et OPTIONAL

Remarques

•  lors de la déclaration des arguments muets d’une procédure, la vocation (attribut INTENT) est interdite au niveau :

•  de la valeur retournée par une fonction,

•  d’un argument de type procédural.

•  INTENT(inout) n’est pas équivalent à l’absence de vocation; par exemple, une constante littérale ne peut jamais être associée à un argument muet ayant l’attribut INTENT(inout) alors qu’elle peut l’être à l’argument sans vocation si ce dernier n’est pas redéfini dans la procédure;

•  un argument muet protégé par la vocation INTENT(in) doit conserver cette protection dans les autres procédures auxquelles il est susceptible d’être transmis;

•  depuis la norme 2003, il est permis de préciser la vocation aux arguments muets ayant l’attribut POINTER; c’est alors l’association qui est concernée et non la cible :

•  INTENT(IN) : le pointeur ne pourra ni être associé, ni mis à l’état nul, ni alloué au sein de la procédure ;

•  INTENT(OUT) : le pointeur est forcé à l’état indéfini à l’entrée de la procédure ;

•  INTENT(INOUT) : le pointeur peut à la fois transmettre une association préétablie et retourner une nouvelle association.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              161 / 314

Interface de procédures et modules

Passage d’arguments par mot-clé

Passage d’arguments par mot-clé

À l’appel d’une procédure, il est possible de passer des arguments par mots-clé ou de panacher avec des arguments positionnels. Pour la prise en compte des arguments optionnels, il est recommandé d’utiliser le passage par mots-clé. Le panachage reste possible sous deux conditions :



1   les arguments positionnels doivent toujours précéder ceux à mots-clé,

2   parmi les arguments positionnels, seuls les derniers pourront alors être omis s’ils sont optionnels.

Exemples supposant rg_max avec l’attribut OPTIONAL :

call maxmin(vect=v, v_max=vmax, v_min=vmin, ctl=control, rg_max=rgmax) call maxmin(v, vmax, vmin, ctl=control) call maxmin(v, vmax, ctl=control, v_min=vmin)

L’exemple suivant fait appel au sous-programme maxmin avec interface « explicite » du fait de son utilisation comme procédure interne. Les erreurs de cohérence signalées plus haut seraient toutes détectées à la compilation.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              162 / 314

Interface de procédures et modules

Interface explicite : procédure interne

Expliciter l’interface via une procédure interne est une solution simple et permet bien de résoudre à la compilation tous les cas d’erreurs signalés. Elle présente néanmoins des inconvénients qui en limitent l’utilisation :

•  la procédure interne n’est pas visible de l’extérieur,

•  programmation lourde et non modulaire.

Nous verrons plus loin qu’il existe cinq solutions pour profiter de la fiabilité associée à l’interface explicite.

Remarques

•  il n’est pas possible d’imbriquer les procédures internes ; l’instruction CONTAINS ne peut appraître qu’une seule fois;

•  les procédures internes et la procédure les contenant forment une même et unique scoping unit ;

•  l’instruction IMPLICIT NONE précisée pour une procédure s’applique également à ses procédures internes;

•  si l’instruction IMPLICIT NONE est spécifiée dans la partie « data » (specification part) d’un module, celle-ci n’est pas exportable via l’instruction USE;

•  dans une procédure interne, une variable déjà présente dans l’appelant est :

•  globale si elle n’est pas explicitement redéclarée,

•  locale si elle est explicitement redéclarée.

D’où l’intérêt particulier de préciser l’instruction IMPLICIT NONE pour des procédures avant leur conversion en procédures internes Fortran 90. La nécessité de tout déclarer évite alors le risque de « globaliser » à tort des variables locales homonymes.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              164 / 314

Interface de procédures et modules

Interface explicite : 5 possibilités

Interface explicite : 5 possibilités

1   procédures intrinsèques (Fortran 77 et Fortran 95),

2   procédures internes (CONTAINS),

3   présence du bloc interface dans la procédure appelante,

4   la procédure appelante accède (USE) au module contenant le bloc interface de la procédure appelée,

5   la procédure appelante accède (USE) au module contenant la procédure appelée.

Le cas 2 a déjà été traité et commenté dans l’exemple précédent ; les cas 3, 4 et 5 seront exploités ci-après en adaptant ce même exemple.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              165 / 314

Interface de procédures et modules

Interface explicite : bloc interface

Interface explicite avec bloc interface

Pour éviter les inconvénients de la procédure interne tout en conservant la fiabilité de l’interface « explicite », Fortran 90 offre la solution du bloc interface qui permet de donner là où il est présent une visibilité complète sur l’interface d’une procédure externe. Ce bloc interface peut être créé par copie de la partie déclarative des arguments muets de la procédure à interfacer. Il sera inséré dans chaque unité de programme faisant référence à la procédure externe.

Avec cette solution la procédure reste bien externe (modularité), mais il subsiste la nécessité de dupliquer le bloc interface (dans chaque procédure appelante) avec les risques que cela comporte Par ailleurs le contrôle de cohérence est fait entre les arguments d’appel et les arguments muets définis dans le bloc interface et non pas ceux de la procédure elle-même!

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              166 / 314


Interface de procédures et modules

Interface explicite : ses apports

Interface explicite : ses apports

•  la transmission du profil et de la taille des tableaux à profil implicite et la possibilité de les récupérer via les fonctions SHAPE et SIZE,

•  la possibilité de contrôler la vocation des arguments en fonction des attributs INTENT et OPTIONAL : en particulier l’interdiction de passer en argument d’appel une constante (type PARAMETER ou numérique) si l’argument muet correspondant a la vocation OUT ou INOUT,

•  la possibilité de tester l’absence des arguments optionnels (fonction PRESENT),

•  le passage d’arguments par mot-clé,

•  la détection des erreurs liées à la non cohérence des arguments d’appel et des arguments muets (type, attributs et nombre) ; conséquence fréquente d’une faute de frappe, de l’oubli d’un argument non optionnel ou de l’interversion de deux arguments.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              169 / 314

Interface de procédures et modules

Interface explicite : module et bloc interface

Interface explicite : module et bloc interface

Pour améliorer la fiabilité générale du programme et s’assurer d’une parfaite homogénéité du contrôle des arguments il faut insérer le même bloc interface dans toutes les unités de programme faisant référence à la procédure concernée (le sous-programme maxmin dans notre exemple).

C’est là le rôle du module et de l’instruction USE permettant l’accès à son contenu dans une unité de programme quelconque.

Un module est une unité de programme particulière introduite en Fortran 90 pour encapsuler entre autres :

•  des données et des définitions de types dérivés,

•  des blocs interfaces,

•  des procédures (après l’instruction CONTAINS),

Quel que soit le nombre d’accès (USE) au même module, les entités ainsi définies sont uniques (remplace avantageusement la notion de COMMON).

Doit être compilé séparément avant de pouvoir être utilisé.

Afin de réaliser une interface « explicite », les exemples suivant font l’utilisation d’un module renfermant le bloc interface dans le 1er puis la procédure elle-même (solution la plus sûre).   

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              170 / 314


Interface de procédures et modules

Cas d’interface explicite obligatoire

Cas d’interface explicite obligatoire

Il est des cas où l’interface d’appel doit être « explicite » :

•  fonction à valeur tableau,

•  fonction à valeur pointeur,

•  fonction à valeur chaîne de caractères dont la longueur est déterminée dynamiquement,

•  tableau à profil implicite,

•  argument muet avec l’attribut allocatable, pointer ou target,

•  passage d’arguments à mots-clé,

•  argument optionnel,

•  procédure générique,

•  surcharge ou définition d’un opérateur,

•  surcharge du symbole d’affectation.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

173 / 314



Interface générique

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules

9    Interface générique

Introduction

Exemple avec module procedure

Exemple : contrôle de procédure F77

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

179 / 314

Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

180 / 314

Interface générique

Introduction

Interface générique : introduction

Possibilité de regrouper une famille de procédures sous un nom générique défini via un bloc interface nommé. À l’appel de la fonction générique, le choix de la procédure à exécuter est fait automatiquement par le compilateur en fonction du nombre et du type des arguments.

Cette notion existe en Fortran 77, mais reste limitée aux fonctions intrinsèques : selon le type de x, pour évaluer abs(x), le compilateur choisit (notion de fonction générique) :

•  iabs(x) si x entier,

•  abs(x) si x réel simple précision,

•  dabs(x) si x réel double précision,

•  cabs(x) si x complexe simple précision.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              181 / 314

Interface générique

Exemple avec module procedure

Définition d’une fonction générique maxmin s’appliquant aux vecteurs qu’ils soient de type réel ou de type entier ? deux sous-programmes très voisins :

•  rmaxmin si vect réel,

•  imaxmin si vect entier,

Nous allons successivement :

1   créer les deux sous-programmes rmaxmin et imaxmin,

2   les stocker dans un module big_maxmin,

MODULE PROCEDURE rmaxmin, imaxmin

3   stocker dans ce même module un bloc interface familial de nom maxmin référençant les 2 sous-programmes via l’instruction :

4   compiler ce module pour obtenir son descripteur () et son module objet,

5   créer un exemple d’utilisation en prenant soin de donner accès (via USE) au module contenant l’interface générique en tête de toute unité de programme appelant le sous-programme maxmin.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              182 / 314


                                                                                  Interface générique             Exemple avec module procedure

Remarque s’il n’était pas possible de stocker tout ou partie des sous-programmes rmaxmin, imaxmin, etc. dans le module big_maxmin, on pourrait néanmoins les faire participer à la généricité en insérant leurs parties déclaratives dans le bloc interface familial. Par exemple : Exemple

interface maxmin MODULE PROCEDURE imaxmin subroutine rmaxmin(vect,v_max,v_min,ctl,rg_max)

                              real, dimension(:), intent(in)                                      :: vect

Interface générique

Exemple : contrôle de procédure F77

Contrôle de procédure F77 via interface « générique et explicite »

Figure 2 :appel classique d’un sous-progr. SP disponible sous forme d’un module objet sans contrôle inter-procédural

Figure 3 :idem en contrôlant le passage d’arguments via un « bloc interface »

Figure 4 :idem en utilisant un bloc interface générique SP appelant un sous-programme control_SP contrôlant l’appel de SP avec la notion d’arguments optionnels et de valeurs par défaut associées (cf. exemple ci-après).   

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017                    186 / 314

real,             intent(out)         :: v_max,v_min integer, optional, intent(out)    :: rg_max integer,            intent(inout) :: ctl end subroutine rmaxmin

end interface maxmin !<-- F95 only

Exemple : contrôle de procédure Fortran 77

Nous allons maintenant montrer une application très particulière de l’interface générique permettant de fiabiliser l’appel d’une procédure Fortran 77 dont on ne pourrait (pour une raison quelconque) modifier ou accéder au source. L’objectif est de pouvoir l’appeler en passant les arguments d’appel par mot clé en imposant une valeur par défaut à ceux qui


sont supposés optionnels et manquants.

Patrick Corde Hervé Delouis ( )                                                       Langage Fortran(Avancé)


26 juin 2017                  185 / 314



Surcharge ou création d’opérateurs

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10 Surcharge ou création d’opérateurs

Introduction

Interface operator

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

191 / 314

Surcharge ou création d’opérateurs

Interface assignment

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

192 / 314

Surcharge ou création d’opérateurs

Introduction

Surcharge d’opérateurs - Introduction

Certaines notions propres aux langages orientés objets ont été incluses dans la norme Fortran 90 notamment la possibilité de surcharger les opérateurs pré-définis du langage. Surcharger ou sur-définir un opérateur c’est élargir son champ d’application en définissant de nouvelles relations entre objets.

Lors de la surcharge d’un opérateur, on doit respecter sa nature (binaire ou unaire). De plus il conserve sa priorité définie par les règles de précédence du langage.

Lorsque l’on applique un opérateur à des expressions, une valeur est retournée. On emploiera donc des procédures de type function pour surcharger un tel opérateur.

Par contre, le symbole d’affectation (=), ne retournant aucune valeur, doit être sur-défini à l’aide d’une procédure de type subroutine.

De plus, la norme permet la définition de nouveaux opérateurs.

Il est bon de noter que le symbole d’affectation (=) ainsi que certains opérateurs arithmétiques et logiques ont déjà fait l’objet d’une sur-définition au sein du langage.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              193 / 314


Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

201 / 314

Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Introduction

Instructions PRIVATE et PUBLIC

Attributs PRIVATE et PUBLIC

Type dérivé semi-privé

Exemple avec contrôle de la visibilité

Paramètre ONLY de l’instruction USE

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

202 / 314


Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Introduction

Introduction

Le concepteur d’un module a la possibilité de limiter l’accès aux ressources (variables, constantes symboliques, définitions de type, procédures) qu’il se définit à l’intérieur de celui-ci. Il pourra par exemple cacher et donc rendre non exportables (via l’instruction use) certaines variables et/ou procédures du module.

Ceci peut se justifier lorsque certaines ressources du module ne sont nécessaires qu’à l’intérieur de celui-ci. De ce fait, le concepteur se réserve le droit de les modifier sans que les unités utilisatrices externes ne soient impactées.

Cela permettra également d’éviter les risques de conflits avec des ressources d’autres modules.

Ces ressources non exportables sont dites privées. Les autres sont dites publiques.

Par défaut, toutes les ressources d’un module (variables, procédures) sont publiques.

La privatisation de certaines données (concept d’encapsulation de données) conduit le concepteur à fournir au développeur des méthodes (procédures publiques) facilitant la manipulation globale d’objets privés ou semi-privés. Leur documentation et leur fourniture est un aspect important de la programmation objet.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              203 / 314

Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Type dérivé semi-privé

Type dérivé « semi-privé »

Les attributs précédents peuvent également s’appliquer aux types dérivés. Un type dérivé peut être :

•  public ainsi que ses composantes, on parle alors de type dérivé transparent.

•  privé

•  public mais avec toutes ses composantes privées. On parle alors de type dérivé « semi-privé ».

L’intérêt du type dérivé « semi-privé » est de permettre au concepteur du module le contenant d’en modifier sa structure sans en affecter les unités utilisatrices.

Par défaut les composantes d’un type dérivé public sont publiques.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              206 / 314


Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Exemple avec contrôle de la visibilité

Remarques

•  concernant l’affectation u = v, bien que celle-ci ait un sens il peut être intéressant d’en avoir la totale maîtrise dans le but d’effectuer un certain nombre de contrôles : pour cela on surcharge le symbole d’affectation. Sur la page suivante, on a donc ajouté au sein du bloc « interface assignment(=) » un sous-programme affect que l’on définit ensuite;

•  les objets de type OBJ_MAT retournés par les fonctions telles que add et trans sont temporaires : lors de leur disparition en mémoire, gérée par le compilateur, la norme

Fortran 2003 précise que les composantes ayant l’attribut ALLOCATABLE (ici mat) sont automatiquement désallouées;

•  dans le cas où l’attribut POINTER était indiqué à la place de ALLOCATABLE pour cette composante, la gestion mémoire aurait été sous la responsabilité du programmeur : pour ce faire celui-ci dispose de procédures spécifiques appelées final procedure. Se reporter au cours Fortran 2003 pour plus de précisions.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              213 / 314


Procédures récursives

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

217 / 314

Procédures récursives

12   Procédures récursives

Clauses RESULT et RECURSIVE

Exemple : suite de Fibonacci

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

218 / 314

Procédures récursives

Clauses RESULT et RECURSIVE

Clauses RESULT/RECURSIVE

En Fortran 90 on peut écrire des procédures (sous-programmes ou fonctions) récursives.

recursive function f(x) result(f_out) recursive subroutine sp(x, y, )

recursive logical function f(n) result(f_out) logical recursive function f(n) result(f_out)

?

?? Définition :

??

Attention : dans le cas d’une fonction récursive, pour que l’emploi du nom de la fonction dans le corps de celle-ci puisse indiquer un appel récursif, il est nécessaire de définir une variable résultat par l’intermédiaire de la clause RESULT lors de la définition de la fonction.

Remarques

•  le type de la variable résultat est toujours celui de la fonction,

•  possibilité d’utiliser la clause RESULT pour les fonctions non récursives.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              219 / 314

Procédures récursives

Exemple : suite de Fibonacci

Attention, au niveau du bloc ELSE :

1   Il serait tentant de programmer cette fonction sous la forme :

fibo = fibonacci(n-1) + fibonacci(n-2)

qui est plus proche de la définition

mathématique de la suite. Bien que parfaitement valide, cette dernière solution serait prohibitive en terme de performance car elle empilerait deux appels récursifs (au lieu d’un seul) et conduirait à recalculer de très nombreux termes déjà évalués !

2   Une autre possibilité serait de programmer sous la forme :

fibo = fibonacci(n-1) + antepenult

qui est une expression interdite par la

norme Fortran 95! En effet, dans une expression, l’appel d’une fonction n’a pas le droit de modifier une entité (ici la variable locale antepenult avec l’attribut SAVE) intervenant dans cette expression. De plus, l’appel de la fonction fibonacci doit obligatoirement précéder le cumul de antepenult dans fibo d’où le découpage en deux instructions.

Note : pour un exemple de sous-programme récursif, cf. page 155

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              221 / 314

Nouveautés sur les E/S

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

222 / 314


Nouveautés sur les E/S

e=’no’)

ion READ ion READ

12   Procédures récursives

13   Nouveautés sur les E/S

Accès aux fichiers pré-connectés

OPEN (status, position, pad, action, delim) INQUIRE (recl, action, iolength, )

Entrées-sorties sur les fichiers texte (advanc

Paramètres IOSTAT et IOMSG de l’instruct

Paramètres IOSTAT et IOMSG de l’instruct

Instruction NAMELIST

Spécification de format minimum

14   Nouvelles fonctions intrinsèques

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

223 / 314

Nouveautés sur les E/S

Accès aux fichiers pré-connectés

Accès aux fichiers pré-connectés

Le compilateur Fortran 2003 est livré avec plusieurs modules intrinsèques tel que ISO_FORTRAN_ENV qui contient des constantes symboliques permettant notamment le référencement des fichiers pré-connectés :

•  INPUT_UNIT, OUTPUT_UNIT et ERROR_UNIT sont des entiers correspondant aux numéros des unités logiques relatifs à l’entrée standard, la sortie standard et à la sortie d’erreur. Ils remplacent avantageusement l’astérisque employé traditionnellement au niveau du paramètre UNIT des instructions READ/WRITE;

•  IOSTAT_END et IOSTAT_EOR sont des entiers correspondant aux valeurs négatives prises par le paramètre IOSTAT des instructions d’entrée/sortie en cas de fin de fichier ou de fin d’enregistrement. Cela permet d’enrichir la portabilité d’un code Fortran. Cependant, les cas d’erreurs génèrent une valeur positive restant dépendante du constructeur.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              224 / 314

Nouveautés sur les E/S

OPEN (status, position, pad, action, delim)

InstructionOPEN

1   NEWUNIT=

•   ce nouveau mot-clé, introduit par la norme 2008, permet de spécifier une variable entière qui sera valorisée à l’issue de l’OPEN à un numéro d’unité logique n’interférant pas avec ceux déjà employés, notamment ceux concernant les fichiers pré-connectés;

2   STATUS=

•   ’REPLACE’ : si le fichier n’existe pas, il sera créé, sinon il sera détruit et un fichier de même nom sera créé.

3   POSITION=

•   ’REWIND’ : indique que le pointeur du fichier sera positionné à son début;

•   ’APPEND’ : indique que le pointeur du fichier sera positionné à sa fin;

•   ’ASIS’ : permet de conserver la position du pointeur du fichier; Ne fonctionne que si le fichier est déjà connecté. C’est utile lorsque l’on désire (via l’instruction OPEN) modifier certaines caractéristiques du fichier tout en restant positionné (valeur par défaut). Très limitatif et dépendant du constructeur!

4   PAD=

•   ’YES’ : des enregistrements lus avec format sont complétés avec des blancs (padding) dans le cas où la liste de variables à traîter et le format correspondant nécessitent plus de caractères que l’enregistrement n’en contient. (valeur par défaut).

•   ’NO’ : pas de padding.

5   ACTION=

•   ’READ’ : toute tentative d’écriture est interdite;

•   ’WRITE’ : toute tentative de lecture est interdite;

•   ’READWRITE’ : les opérations de lecture et écriture sont autorisées (valeur par défaut).

6   DELIM=? ce paramètre permet de délimiter les chaînes de caractères écrites par des namelist ou en format libre :

•   ’APOSTROPHE’ : indique que l’apostrophe « ’ » sera utilisée ;

•   ’QUOTE’ : indique que le guillemet « " » sera utilisée;

•   ’NONE’ : indique qu’aucun délimiteur ne sera utilisé (valeur par défaut).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017                    225 / 314

                                                                             Nouveautés sur les E/S                  INQUIRE (recl, action, iolength, )

Instruction INQUIRE

•  RECL=n : permet de récupérer la longueur maximale des enregistrements.

•  POSITION=chaîne : permet de récupérer la valeur du même paramètre spécifié lors de l’open.

•  ACTION=chaîne : permet de récupérer la valeur du même paramètre spécifié lors de l’open.

•  DELIM=chaîne : permet de récupérer la valeur du même paramètre spécifié lors de l’open.

•  IOLENGTH=long : permet de récupérer la longueur de la liste des entités spécifiées. C’est utile lorsque l’on veut valoriser le paramètre RECL de l’ordre OPEN pour un fichier binaire à accès direct.

•  PAD=chaîne : permet de récupérer la valeur du même paramètre spécifié lors de l’OPEN. Exemples

inquire(9, opened=op, action=ac) inquire(file="donnee", position=pos) inquire(iolength=long)x,y,tab(:n)

open(2,status="scratch",action="write",access="direct",recl=long)

Note : l’argument IOLENGTH de l’instruction INQUIRE permet de connaître la longueur (E./S. binaires) d’une structure de type dérivé (sans composante pointeur) faisant partie de la liste spécifiée.

226 / 314

                                                                             Nouveautés sur les E/S                  Entrées-sorties sur les fichiers texte (advance=’no’)

Entrées-sorties sur les fichiers texte (advance=’no’)

Le paramètre ADVANCE=’no’ des instructions READ/WRITE (ADVANCE=’yes’ par défaut) permet de rester positionner sur l’enregistrement courant.

Dans le cas d’une lecture avec format explicite et en présence du paramètre

ADVANCE=’no’ :

•  le paramètre EOR=nnn effectue un transfert à l’étiquette nnn lorsqu’une fin d’enregistrement est détectée ;

•  le paramètre SIZE=long ( long variable de type INTEGER) de l’instruction READ permet de récupérer le nombre de caractères transférés lors de la lecture. Dans le cas où la fin d’enregistrement est détectée, ce nombre ne tient pas compte du padding si padding il y a (paramètre PAD valorisé à ’yes’ lors de l’OPEN).

Note : ADVANCE=’no’ est incompatible avec le format libre.

Une alternative aux paramètres END=nnn et EOR=nnn de l’instruction READ est l’emploi du paramètre IOSTAT. Il retourne un entier :

•  positif en cas d’erreur;

•  négatif lorsqu’une fin de fichier ou une fin d’enregistrement est atteinte (valeurs


dépendant du constructeur);

• nul sinon. Exemple

read(8, fmt=9, advance="no", size=n, eor=7, end=8) list read(8, fmt=9, advance="no", size=n, iostat=icod) list

Patrick Corde Hervé Delouis ( )                                                    Langage Fortran(Avancé)


26 juin 2017                  227 / 314


Nouveautés sur les E/S

Instruction NAMELIST

Norme 95 : possibilité de commenter via le caractère « ! » des enregistrements en entrée d’une NAMELIST :

&TRUC x=2*0.0! x est un tableau text="abcde" n=3 /

Note : en Fortran 77, la fin des données était en général repérée par &END ou $END au lieu de « / » et les enregistrements devaient commencer par un blanc. La relecture de données codées avec l’ancien format est soit automatiquement compatible (ex : ifort d’INTEL), soit assurée via :

• une variable (export XLFRTEOPTS="namelist=old" sur IBM).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              232 / 314

Nouveautés sur les E/S

Spécification de format minimum

Spécification de format

Norme 95 : afin de permettre l’écriture formatée de variables sans avoir à se préoccuper de la largeur du champ récepteur, il est possible de spécifier une longueur nulle avec les formats I, F, B, O et Z :

write(6,"(2I0,2F0.5,E15.8)") int1,int2,x1,x2,x3

On évite ainsi l’impression d’astérisques bien connue des programmeurs Fortran dans le cas d’un débordement de la zone réceptrice.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              233 / 314

Nouvelles fonctions intrinsèques

1    Introduction

2    Généralités

3    Types dérivés

4    Programmation structurée

5    Extensions tableaux

6    Gestion mémoire

7    Pointeurs

8    Interface de procédures et modules 9 Interface générique

10   Surcharge ou création d’opérateurs

11   Contrôle de visibilité, concept d’encapsulation et gestion de zones dynamiques

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

234 / 314


Nouvelles fonctions intrinsèques

)

)

ng,

12   Procédures récursives

13   Nouveautés sur les E/S

14   Nouvelles fonctions intrinsèques Accès à l’environnement,

Précision/codage numérique : tiny/huge, sign, nearest, spaci

Mesure de temps, date, nombres aléatoires

Transformation (transfer)

Conversion entiers/caractères (char, ichar, ) Comparaison de chaînes (lge, lgt, lle, llt Manipulation de chaînes (adjustl, index, Opérations sur les bits (iand, ior, ishft, )

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

235 / 314

Nouvelles fonctions intrinsèques

Accès à l’environnement,

GET_ENVIRONMENT_VARIABLE( name [,value] [,length] [,status] [,trim_name] )

•  name est une chaîne de caractères valorisée au nom de la variable d’environnement dont on désire le contenu ;

•  value est une chaîne de caractères dans laquelle sera retournée le contenu de la variable d’environnement fournie ci-dessus. Une chaîne à blancs sera renvoyée dans les cas suivant :

•  la variable d’environnement indiquée n’existe pas;

•  la variable d’environnement existe mais son contenu est vide;

•  la notion de variable d’environnement n’existe pas sur la plateforme utilisée.

•  length est un entier qui sera valorisé à la longueur de la valeur de la variable d’environnement fournie si celle-ci existe et a un contenu défini. Sinon 0 sera la valeur retournée;

•  status est un entier qui sert de code retour qui est valorisé de façon suivante :

•  si la variable d’environnement existe avec un contenu vide ou bien admet une valeur retournée avec succès,

0 sera la valeur retournée;

•  si la variable d’environnement existe et admet un contenu dont la taille est supérieure à celle de la chaîne de caractères fournie via le paramètre value, -1 sera retournée ;

•  ce code de retour est valorisé à 1 si la variable d’environnement n’existe pas et à 2 si il n’y a pas de notion de variable d’environnement sur la plateforme utilisée.

•  trim_name est un logique. S’il a pour valeur .FALSE. alors les caractères blancs situés à la fin du paramètre name seront considérés comme significatifs. Ils seront ignorés dans les autres cas.    

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              238 / 314

Nouvelles fonctions intrinsèques

Précision/codage numérique : tiny/huge, sign, nearest, spacing,

Précision et codage numérique

TINY(x)                        plus petite valeur réelle représentable dans le sous-type de x (limite de

l’underflow).

HUGE(x)                     plus grande valeur réelle ou entière représentable dans le sous-type de x (limite de l’overflow).

NEAREST(x, s) valeur réelle représentable la plus proche (à droite si s>0. ou à gauche si s<0.) de la valeur représentable correspondant à l’argument réel x fourni. Dépendant du sous-type de x.

SPACING(x)               écart entre deux valeurs représentables dans le sous-type de x au voisinage de x.

EPSILON(x)               ?SPACING(+1.) : quantité considérée comme négligeable comparée à 1.

RANGE(x)    c.f. chapitre 2 – Généralités (KIND). PRECISION(x)         c.f. chapitre 2 – Généralités (KIND).

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              241 / 314

Nouvelles fonctions intrinsèques

Précision/codage numérique : tiny/huge, sign, nearest, spacing,

SIGN(a,b)                   entier/réel dont la valeur absolue est celle de a et le signe celui de b. Seule fonction distinguant +0. et -0. si ce dernier est représentable.

Note: le zéro réel classique (+0.) a une représentation binaire totalement nulle alors que le zéro négatif (-0.) a son bit de signe positionné à 1 (’80000000’ en hexa.). Seule la fonction SIGN (au niveau du 2e argument) fait la distinction entre ces deux zéros. Cette distinction peut aussi être faite via une impression en format libre. La valeur -0. est représentable sur NEC SX8 et IBM SP6.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              242 / 314

Nouvelles fonctions intrinsèques

Mesure de temps, date, nombres aléatoires

Mesure de temps, nombres aléatoires

CPU_TIME(time) (disponible depuis la norme 95) sous-progr. retournant dans le réel time le temps CPU en secondes (ou réel < 0 si indisponible). Par différence entre deux appels, il permet d’évaluer la consommation CPU d’une section de code.

DATE_AND_TIME(date,time,zone,values) sous-programme retournant dans les variables caractère date et time, la date et l’heure en temps d’horloge murale. L’écart par rapport au temps universel est retourné optionnellement dans zone. Toutes ces informations sont aussi stockées sous forme d’entiers dans le vecteur values.

SYSTEM_CLOCK(count,count_rate,count_max) sous-programme retournant dans des variables entières la valeur du compteur de périodes d’horloge (count), le nombre de périodes/sec. (count_rate) et la valeur maximale de ce compteur (count_max); ne permet pas d’évaluer le temps CPU consommé par une portion de programme.

RANDOM_NUMBER(harvest) sous-progr. retournant un/plusieurs nombres pseudo-aléatoires compris entre 0. et 1. dans un scalaire/tableau réel passé en argument (harvest).

RANDOM_SEED(size,put,get) sous-programme permettant de ré-initialiser une série de nombres aléatoires. Tous les arguments sont optionnels. En leur absence le germe d’initialisation dépend du constructeur. Voir exemples ci-après  

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              243 / 314


Nouvelles fonctions intrinsèques

Conversion entiers/caractères (char, ichar, )

Conversions entiers/caractères

•  CHAR(i,[kind])

? iième caractère de la table standard (ASCII/EBCDIC) si kind absent, sinon de la table correspondant à kind (constructeur dépendant).

•  ACHAR(i)

? idem CHAR avec table ASCII.

•  ICHAR(c,[kind])

? rang (entier) du caractère c dans la table associée à la valeur du mot-clé kind (ASCII/EBCDIC en général).

•  IACHAR(c) idem ICHAR dans la table ASCII.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              250 / 314


Nouvelles fonctions intrinsèques

Comparaison de chaînes (lge, lgt, lle, llt)

Comparaison de chaînes

•  LGE(string_a, string_b)

? VRAI si string_a « supérieure ou = » à string_b

(Lexically Greater or Equal);

•  LGT(string_a, string_b)

? VRAI si string_a « supérieure » à string_b

(Lexically Greater Than);

•  LLE(string_a, string_b)

? VRAI si string_a « inférieure ou = » à string_b

(Lexically Less or Equal);

•  LLT(string_a, string_b)

? VRAI si string_a « inférieure » à string_b (Lexically Less Than).

Remarques

•  La comparaison des chaînes s’effectue caractère par caractère à partir de la gauche en fonction de leur rang dans la table ASCII;

•  En cas d’inégalité de longueur, la chaîne la plus courte est complétée à blanc sur sa droite;

•  Ces quatre fonctions faisaient déjà partie de la norme 77;

•  Les opérateurs >=, >, <= et < équivalents à ces fonctions peuvent aussi être utilisés. Il n’existe pas de fonctions LEQ et LNE équivalentes aux opérateurs == et /=.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              251 / 314

Nouvelles fonctions intrinsèques

Manipulation de chaînes (adjustl, index, )

Manipulation de chaînes

•  ADJUSTL(string)

? débarrasse string de ses blancs de tête (cadrage à gauche) et complète à droite par des blancs.

•  ADJUSTR(string)? idem ADJUSTL mais à droite.

•  INDEX(string, substring [,back])

? numéro (entier) du premier caractère de string où apparaît la sous-chaîne substring (sinon 0). Si la variable logique back est vraie : recherche en sens inverse.

•  LEN_TRIM(string)

? longueur (entier) de la chaîne débarrassée de ses blancs de fin.

•  SCAN(string, set [,back])

? numéro (entier) du premier caractère de string figurant dans set ou 0 sinon. Si la variable logique back est vraie : recherche en sens inverse.

•  VERIFY(string, set [,back])

? numéro (entier) du premier caractère de string ne figurant pas dans set, ou 0 si tous les caractères de string figurent dans set. Si la variable logique back est vraie : recherche en sens inverse.

•  REPEAT(string, ncopies)

? chaîne obtenue en concaténant ncopies copies de string.

•  TRIM(string)? débarrasse string de ses blancs de fin. 

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              252 / 314

Nouvelles fonctions intrinsèques

Opérations sur les bits (iand, ior, ishft, )

Opérations sur les bits

IAND(i,j)                                           fonction retournant un entier de même type que i

résultant de la combinaison bit à bit de i et j par un ET logique.

IEOR(i,j)                                            fonction retournant un entier de même type que i

résultant de la combinaison bit à bit de i et j par un OU exclusif logique.

IOR(i,j)                                              fonction retournant un entier de même type que i

résultant de la combinaison bit à bit de i et j par un OU inclusif logique.

ISHFT(i,shift)                                  fonction retournant un entier de même type que i

résultant du décalage de shift bits appliqué à i. Décalage vers la gauche ou vers la droite suivant que l’entier shift est positif ou négatif. Les bits sortant sont perdus et le remplissage se fait par des zéros.

ISHFTC(i,shift[,size])                        fonction retournant un entier de même type que i résultant d’un décalage circulaire de shift positions appliqué aux size bits de droite de i. Décalage vers la gauche ou vers la droite suivant que l’entier shift est positif ou négatif.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              253 / 314

Nouvelles fonctions intrinsèques

Opérations sur les bits (iand, ior, ishft, )

IBCLR(i,pos)                                                        fonction retournant un entier identique à i avec le posième bit mis à zéro;

IBSET(i,pos)                                                       fonction retournant un entier identique à i avec

le posième bit mis à 1;

NOT(i)                                                                  fonction retournant un entier de même type que

i, ses bits correspondant au complément logique de ceux de i;

IBITS(i,pos,len)                                                  fonction stockant dans un entier de même type que i les len bits de i à partir de la position pos. Ces bits sont cadrés à droite et complétés à gauche par des zéros ;

MVBITS(from,frompos,len,to,topos) sous-programme copiant une séquence de bits depuis une variable entière (from) vers une autre (to).

Remarques



1 ces fonctions ont été étendues pour s’appliquer aussi à des tableaux d’entiers; 2 Norme 95 : le sous-programme MVBITS est « pure » et « elemental ».

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              254 / 314

Annexe A : paramètre KIND et précision des nombres

nombres

15   Annexe A : paramètre KIND et précision des

Sur IBM/SP6

Sur NEC/SX8

16   Annexe B : exercices

17   Annexe C : apports de la norme 95

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

255 / 314

Annexe A : paramètre KIND et précision des nombres

Sur IBM/SP6

paramètre KIND sur IBM/SP6

Type

Variante

Nb octets

Étendue

Précision

Entier

kind=1

1

?128 ? i

? 127

/////////

kind=2

2

?215? i

? 215? 1

/////////

kind=4

4

?231? i

? 231? 1

/////////

kind=8

8

?263? i

? 263? 1

/////////

Réel

kind=4

4

1.2 × 10?38?| r |? 3.4 × 1038

6 chiffres

kind=8

8

2.2 × 10?308?| r |? 1.8 × 10308

15 chiffres

kind=16

16

2.2 × 10?308?| r |? 1.8 × 10308

31 chiffres

Complexe

kind=4

(4,4)

1.2 × 10?38?| r |? 3.4 × 1038

6 chiffres

kind=8

(8,8)

2.2 × 10?308?| r |? 1.8 × 10308

15 chiffres

kind=16

(16,16)

2.2 × 10?308?| r |? 1.8 × 10308

31 chiffres

Logique

kind=1

1

        .true.=01,               .false=00

/////////

kind=2

2

.true.=0001, .false=0000

/////////

kind=4

4

.true.=0..1, .false=0..0

/////////

kind=8

8

.true.=0..1, .false=0..0

/////////

Caractère

kind=1

1

jeu ASCII

/////////

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              256 / 314

Annexe A : paramètre KIND et précision des nombres

Sur NEC/SX8

paramètre KIND sur NEC/SX8

Type

Variante

Nb octets

Étendue

Précision

Entier

kind=2

2

?215? i

? 215? 1

/////////

kind=4

4

?231? i

? 231? 1

/////////

kind=8

8

?263? i

? 263? 1

/////////

Réel

kind=4

4

1.2 × 10?38?| r |? 3.4 × 1038

6 chiffres

kind=8

8

2.2 × 10?308?| r |? 1.8 × 10308

15 chiffres

kind=16

16

2.2 × 10?308?| r |? 1.8 × 10308

31 chiffres

Complexe

kind=4

(4,4)

1.2 × 10?38?| r |? 3.4 × 1038

6 chiffres

kind=8

(8,8)

2.2 × 10?308?| r |? 1.8 × 10308

15 chiffres

kind=16

(16,16)

2.2 × 10?308?| r |? 1.8 × 10308

31 chiffres

Logique

kind=1

1

        .true.=01,               .false=00

/////////

kind=4

4

.true.=0..1, .false=0..0

/////////

kind=8

8

.true.=0..1, .false=0..0

/////////

Caractère

kind=1

1

jeu caractères ASCII

/////////

kind=2

2

jeu caractères Japonais

/////////

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              257 / 314

Annexe B : exercices

nombres

15   Annexe A : paramètre KIND et précision des

16   Annexe B : exercices Énoncés

Exercices : corrigés

17   Annexe C : apports de la norme 95

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

258 / 314

Annexe B : exercices

Énoncés

Exercice 1

Compiler et exécuter le programme contenu dans les fichiers exo1.f90, mod1_exo1.f90 et mod2_exo1.f90 :

program exo1 use mod2 implicit none

real               :: somme integer :: i tab=(/ (i*10,i=1,5) /)

print *, tab call sp1s(somme) print *,somme call sp2s(somme) print *,somme

end program exo1

module mod1 real,dimension(5) :: tab

end module mod1

module mod2 use mod1

contains subroutine sp1s(som) implicit none

real          :: som integer :: I som=0. do i=1,5 som=som+tab(i)

enddo

end subroutine sp1s !-----------------subroutine sp2s(x) implicit none

                  real              :: x

x=-x

end subroutine sp2s

end module mod2

Recommencez en plaçant les modules dans un répertoire différent de celui où se trouve le programme principal.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

259 / 314

Annexe B : exercices

Énoncés

Exercice 2

Écrire un programme permettant de valoriser la matrice identité de n lignes et n colonnes en évitant les traitements élémentaires via les boucles DO pour utiliser autant que possible les fonctions intrinsèques de manipulation de tableaux. Imprimer la matrice obtenue ligne par ligne et explorer plusieurs solutions mettant en œuvre les fonctions RESHAPE, UNPACK, CSHIFT ainsi que le bloc WHERE.

Exercice 3

Complétez le programme suivant en réécrivant les boucles imbriquées à l’aide d’une expression tableaux :

program exo3 implicit none integer, parameter :: nx=100, ny=200, nz=5

real, dimension(nx,ny,nz) :: tab1, tab2

real :: vec1(nx), vec2(ny) integer   :: i, j, k

call random_number(vec1); call random_number(vec2)

! Calculs scalaires

DO k=1,nz

DO j=1,ny

DO i=1,nx tab1(i,j,k)= sqrt(vec1(i))*exp(vec2(j)) ENDDO

ENDDO

ENDDO

! Boucles précédentes réécrites à l’aide d’une expression tableaux :

           !                                                          

!    block

integer, parameter :: k = 3

if ( maxval(abs(tab1-tab2)) < minval(k*spacing(tab1)) ) then print *, "tab1==tab2"

else print *, "tab1/=tab2"

end if

end block end program exo3

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              260 / 314

Annexe B : exercices

Énoncés

Exercice 4

Écrire un programme permettant de valoriser une matrice de n lignes et m colonnes (n et m n’étant connus qu’au moment de l’exécution) de la façon suivante :

1   les lignes de rang pair seront constituées de l’entier 1,

2   les lignes de rang impair seront constituées des entiers successifs 1, 2, 3, .

                                                                                                                 1          2       3          4

                                                                                    Par exemple :           1      1       1      1

                                                                                                                    5      6       7      8

Imprimer la matrice obtenue ligne par ligne afin de vérifier son contenu.

Exercice 5

Allouer une matrice réelle NxN (N multiple de 4); l’initialiser avec real(i) pour i variant de 1 à N*N. Transformer cette matrice en réordonnant les lignes et les colonnes de la façon suivante (pour N=16) :

| 1 2| 3 4| 5 6| 7 8| 9 10|11 12|13 14|15 16| transformé en :

|15 16| 1 2|13 14| 3 4|11 12| 5 6| 9 10| 7 8|

Autrement dit, ramener les 2 dernières colonnes/lignes devant les 2 premières colonnes/lignes et garder ces 4 colonnes/lignes ensembles. Réitèrer ce processus en repartant des 2 dernières colonnes/lignes sans déplacer celles dejà transformées et ainsi de suite Imprimer la matrice avant et après transformation et vérifier que la trace de la matrice est inchangée.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              261 / 314

Annexe B : exercices

Énoncés

Exercice 6

Écrire un programme permettant de reconnaître si une chaîne est un palindrome. Lire cette chaîne dans une variable de type character(len=long) qui sera ensuite transférée dans un tableau (vecteur) de type character(len=1) pour faciliter sa manipulation via les fonctions intrinsèques tableaux. Écrire ce programme de façon modulaire et évolutive; dans un premier temps, se contenter de lire la chaîne (simple mot) au clavier et dans un deuxième, ajouter la possibilité de lire un fichier (cf. fichier palindrome) contenant des phrases (suite de mots séparés par des blancs qu’il faudra supprimer – phase de compression).

Exercice 7

Compléter le programme contenu dans le fichier exo7.f90 jusqu’à ce qu’il s’exécute correctement : les 2 matrices imprimées devront être identiques.

program exo7 implicit none integer, parameter :: n=5,m=6 integer(kind=2)              :: i

integer, dimension(0:n-1,0:m-1) :: a = reshape((/ (i*100,i=1,n*m) /), shape(a)) print *,"Matrice a avant appel à sp :" print *,"--------------------------" do i=0,size(a,1)-1 print *,a(i,:)

enddo call sp(a)

end program exo7 subroutine sp(a)

integer          :: i integer, dimension(:,:) :: a print *

print *,"Matrice a dans sp :" print *,"-----------------" do i=0,size(a,1)-1 print *,a(i,:)

enddo end subroutine sp

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              262 / 314

Annexe B : exercices

Énoncés

Exercice 8

Écrire un programme permettant l’impression des n premières lignes du triangle de Pascal avec allocation dynamique du triangle considéré comme un vecteur de lignes de longueur variable.

                                                                                                         ? 1                                        ?

                                                                                                                1      1

                                                                               Par exemple :            1      2      1

                                                                                                         ?                                 ?

                                                                                                                1      3      3      1

                                                                                                                1      4      6      4       1

Exercice 9

Développez le module « surcharge » afin que le source suivant produise la sortie qui suit :

program exo9 use surcharge

integer i, j logical b1, b2

b1 = .true.; b2 = .false. i = b1; j = b2 print *,"b1 =", b1, " i =", i print *,"b2 =", b2, " j =", j

if ( b1 == b2 ) print *, "b1 == b2" if ( b1 /= b2 ) print *, "b1 /= b2" end program exo9 Sortie :

b1 = T, i = 1 b2 = F, j = 0 b1 /= b2

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              263 / 314

Annexe B : exercices

Énoncés

Exercice 10

Cet exercice reprend le module matrix des chapitres 10 et 11 (cf. page 209) du support de cours. Il est stocké (avec un programme principal d’utilisation complet) dans le fichier exo10.f90.

Complétez le module matrix en définissant un opérateur .vp. permettant le calcul des valeurs propres d’un objet de type OBJ_MAT. Utilisez par exemple le sous-programme EVLRG (calculant les valeurs propres d’une matrice réelle d’ordre N) de la bibliothèque IMSL dont la séquence d’appel est :

             CALL EVLRG(N, A, LDA, EVAL)             avec :

-  N       : nombre de lignes de A            (entrée) - A               : matrice réelle d’ordre N (entrée)

-  LDA : "Leading Dimension of A" (N ici) (entrée)

-  EVAL : vecteur contenant les N valeurs (sortie) propres complexes

En entrée :

le programme principal lit (en « format libre » et avec le paramètre ADVANCE="NO") un fichier avec un enregistrement contenant :

•  un entier représentant l’ordre N de la matrice,

•  N*N valeurs réelles représentant les éléments de la matrice à traiter.

Un exemple d’un tel fichier (avec une matrice d’ordre N=4) est contenu dans . Les valeurs propres attendues sont les suivantes : (4.,0.), (3.,0.), (2.,0.), (1.,0.).

Notes :

•  deux méthodes ont déjà été ajoutées au module matrix :

1      la fonction logique erreur() permettant de tester la bonne convergence du calcul effectué par EVLRG; 2  le sous-programme imp_vp(vect_complexe) pour faciliter l’impression des valeurs propres.

•  consultez le README du répertoire lapack.

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              264 / 314

Annexe B : exercices

Énoncés

Exercice 11

Soit le programme principal contenu dans le fichier exo11.f90 :

program exo11

use music type(musicien) :: mus_mort_le_plus_jeune call init call tri(critere="nom") call tri(critere="annee") mus_mort_le_plus_jeune = .MortLePlusJeune.tab_mus print * print *,"Le musicien mort le plus jeune est : ", nom(mus_mort_le_plus_jeune)

end program exo11

Dans le module music à créer, définir :

•  le type musicien et un tableau tab_mus de ce type (dimensionné à 30).

•  le sous-programme init devant lire le contenu du fichier musiciens (ce fichier contient une liste de compositeurs avec leurs années de naissance et de mort : éditez-le au préalable afin de connaître son formatage) afin de valoriser le tableau tab_mus et l’imprimer,

•  le sous-programme tri qui trie et imprime la liste des musiciens. Passer en argument le critère de tri sous forme d’une chaîne de caractères et effectuer ce tri par l’intermédiaire d’un tableau de pointeurs,

de sorte que l’exécution de ce programme produise les résultats suivants :

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              265 / 314

Annexe B : exercices

Énoncés

---- Liste des musiciens ----

Johann Sebastian Bach 1685 1750 Georg Friedrich Haendel 1685 1759

                   Wolfgang Amadeus Mozart                                    1756 1791

Giuseppe Verdi 1813 1901 Richard Wagner 1813 1883

Ludwig van Beethoven             1770 1827 . . . . . . . . . . .

. . . . . . . . . . .

                 Igor                              Stravinski                            1882 1971

                     Piotr Ilyitch               Tchaikovski                         1840 1893

Antonio    Vivaldi      1678 1741 Carl Maria von         Weber     1786 1826 Giacomo          Puccini     1858 1924 Claude    Debussy   1862 1918 Joseph             Haydn      1732 1809

                 Gustav                        Mahler                                  1860 1911

---- Liste alphabétique des musiciens ----

Johann Sebastian Bach             1685 1750 Ludwig van                Beethoven               1770 1827 Johannes Brahms     1833 1897 Frederic          Chopin     1810 1849 Claude    Debussy   1862 1918

Georg Friedrich Haendel 1685 1759 . . . . . . . . . . .

. . . . . . . . . . .

Antonio    Vivaldi      1678 1741 Richard   Wagner    1813 1883 Carl Maria von Weber     1786 1826

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

26 juin 2017

266 / 314


Annexe B : exercices

Énoncés

---- Liste chronologique des musiciens ----

Claudio    Monteverdi              1567 1643 Henry     Purcell     1659 1695 Antonio           Vivaldi      1678 1741 Johann Sebastian Bach                1685 1750 Georg Friedrich Haendel         1685 1759

Domenico  Scarlatti 1695 1757 . . . . . . . . . . .

. . . . . . . . . . .

                 Maurice                      Ravel                                    1875 1937

                 Igor                              Stravinski                            1882 1971

Le musicien mort le plus jeune est : Gian-Battista Pergolese

Exercice 12

Même exercice que précédemment mais avec utilisation d’une liste chaînée simple ou double en partant du programme principal suivant contenu dans le fichier exo12.f90 :

program exo12 use music type(musicien) :: mus_mort_le_plus_jeune call init call tri(critere="nom") call tri(critere="annee") mus_mort_le_plus_jeune = .MortLePlusJeune.debut print * print *,"Le musicien mort le plus jeune est : ", nom(mus_mort_le_plus_jeune)

end program exo12

Remarque : debut correspond au pointeur de début de liste.                                                                                                                            

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              267 / 314


Annexe C : apports de la norme 95

nombres

15   Annexe A : paramètre KIND et précision des

16   Annexe B : exercices

17   Annexe C : apports de la norme 95

Procédures « pure »

Procédures « elemental »

Le « bloc FORALL »

Patrick Corde Hervé Delouis ( )

Langage For

tran(Avancé)

26 juin 2017

307 / 314

Annexe C : apports de la norme 95

Procédures « pure »

Voici quelques règles à respecter :

•  ne faire référence qu’à des procédures ayant aussi l’attribut pure et obligatoirement en mode d’interface explicite ;

•  toujours définir la vocation (intent) des arguments muets (sauf ceux de type procédural bien sûr) : pour les fonctions cette vocation est obligatoirement intent(in);

•  pour toute variable « vue » par host ou use association ou via COMMON ou via un argument muet avec intent(in) :

•  ne pas la faire figurer à gauche d’une affectation,

•  ne pas la faire figurer à droite d’une affectation si elle est de type dérivé contenant un pointeur,

•  ne pas la transmettre à une autre procédure si l’argument muet correspondant a l’un des attributs : pointer, intent(out), intent(inout);

•  ne pas lui associer de pointeur.

•  ne pas utiliser d’instruction STOP;

•  les fonctions (ou sous-programmes) surchargeant des opérateurs (ou l’affectation) doivent avoir l’attribut pure.

Remarques

•  les fonctions intrinsèques ont toutes l’attribut pure,

•  l’attribut pure est automatiquement donné aux procédures ayant l’attribut elemental (cf. ci-après).      

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              309 / 314

Annexe C : apports de la norme 95

Procédures « elemental »

Procédures « elemental »

Les procédures « ELEMENTAL » sont définies avec des arguments muets scalaires mais peuvent recevoir des arguments d’appels qui sont des tableaux du même type.

La généralisation du traitement scalaire à l’ensemble des éléments du/des tableaux passés ou retournés suppose bien sûr le respect des règles de conformance au niveau des profils (shape).

Voici les règles à respecter :

•  nécessité d’ajouter le préfixe ELEMENTAL à l’instruction function ou subroutine;

•  l’attribut ELEMENTAL implique l’attribut pure; il faut donc respecter toutes les régles énoncées au paragraphe précédent sur les procédures « pure »;

•  tous les arguments muets et la valeur retournée par une fonction doivent être des scalaires sans l’attribut pointer;

•  si un tableau est passé à un sous-programme « ELEMENTAL », tous les autres arguments à vocation in/inout doivent eux aussi être passés sous forme de tableaux et être conformants ;

•  pour des raisons d’optimisation, un argument muet ne peut figurer dans une specification-expr. c.-à-d. être utilisé dans les déclarations pour définir l’attribut DIMENSION d’un tableau ou la longueur (len) d’une variable de type character;

•  l’attribut ELEMENTAL est incompatible avec l’attribut RECURSIVE.  

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              310 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

Le « bloc FORALL »

[etiquette:]FORALL(index=inf:sup[:pas][,index=inf:sup[:pas]] [,expr_logique_scalaire]) Corps : bloc d’instructions

END FORALL[etiquette]

Le « bloc FORALL » est utilisé pour contrôler l’exécution d’instructions d’affectation ou d’association (pointeur) en sélectionnant des éléments de tableaux via des triplets d’indices et un masque optionnel. Le bloc peut se réduire à une « instruction FORALL » s’il ne contient qu’une seule instruction.

Ce bloc a été défini pour faciliter la distribution et l’exécution des instructions du bloc, en parallèle sur plusieurs processeurs.

Sous le contrôle du « masque », chacune des instructions est interprétée de façon analogue à une "instruction tableau"; les opérations élémentaires sous-jacentes doivent pouvoir s’exécuter simultanément ou dans n’importe quel ordre, l’affectation finale n’étant faite que lorsqu’elles sont toutes terminées.

La séquence des instructions dans le bloc est respectée.

La portée (scope) d’un indice (index) contrôlant un « bloc FORALL » est limitée à ce bloc. En sortie du bloc, une variable externe de même nom retrouve la valeur qu’elle avait avant l’entrée.    

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              312 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

– Symboles –

=> ..139, 201, 215, 289 => (use) ..217 (/ /) . 45, 75 ( :, ,) . 281 ( :, , :) .. 75, 123

.EQ. .. 27 .GE. .. 27 .GT. .. 27

.LE. .. 27 .LT. 27 .NE. .. 27

: : . 29 ; 25 % 49, 197, 199, 201, 289 & ..25 état pointeur associé .. 137 indéfini ..137 nul 137 étendue 39, 71, 73, 81

– A –

achar 251 action .. 227 open . 227

adjustl .. 253 adjustr ..253 advance read/write 229, 231

affectation surcharge . 195, 215

affectation et allocation automatique . 129, 131 aiguillage - select case 67 alias pointeur .137

all .. 91, 277

ALLOCATABLE composante type dérivé . 127 scalaire ..129

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

allocatable . 31, 55, 123, 125, 155, 273, 275, 283, 289 allocate .. 15, 55, 123, 143, 147, 149, 155, 157, 199, 201, 215, 273, 275, 283, 289 allocated .. 123, 211, 215 allocation via affectation 129 ANSI . 11 any .91, 97, 215 argument procédural .179 arguments ligne de commande .. 241

arguments à mot clé .. 161, 187 arguments optionnels . 161, 187 ASA .. 11 associated 147, 157 association .215 assumed-shape-array ..83 assumed-size-array .81 attributs .. 31, 177

–    B –

bibliographie 17 bloc interface .15, 83, 167, 171, 179, 187 bloc interface nommé 183 block .67, 69 boucles implicites ..75

–    C –

case . 291 case default . 67 case( ) 67 champs type dérivé .. 45

char . 251 cible .. 137, 139 COMMAND_ARGUMENT_COUNT 239 commentaires ..27, 29 common 155, 171, 209 compilation . 23 composantes

pointeurs . 55

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

type dérivé .. 45

conformance 91 constantes d’environnement 225 constructeur structure . 45 tableau 45

constructeur de type dérivé ..47 contains .. 15, 165, 167, 171 contrôle procédure 77 .. 187

count 93, 107, 277 cpu_time 15, 245, 247 cross-compilateur NEC sxf90 23 cshift .. 101, 103, 107, 119, 275 dérivée d’une matrice 103 cycle - do/end do ..63

–    D –

déclarations 29, 31, 33 dérivée d’une matrice 119 data .. 13 date . 245 date_and_time .245, 247 deallocate .123, 125, 143, 147, 283 deffered-shape-array . 123 delim 227 open . 227

digits 243 dim fonctions tableaux ..89

dimension .. 31, 71 do - end do .59, 61 do while . 61 dot_product . 95, 97, 119

–    E –

E./S. et type dérivé 53 edition de liens

édition de liens ..23

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

elemental ..15, 313 elsewhere 113, 115 encapsulation . 205 end select 67 end= read ..229

environnement constantes d’ .. 225 eor= read ..229

eoshift . 103, 105, 107 epsilon ..243 equivalence 251 ERROR_UNIT 225 execution exécution .23

exit ..291 exit - do/end do .. 61, 63 exponent 243 expression d’initialisation . 117 de specification 121 external .. 13, 31, 179

– F –

f90 (IBM) . 23, 269 fonction à valeur chaîne .175 fonction à valeur pointeur ..175 fonction à valeur tableau 175 fonction intrinsèque kind 37

fonctions élémentaires 113, 115 fonctions intrinsèques kind 37 selected_int_kind 37, 39, 41 selected_real_kind 37, 39, 41

forall 15, 315 format fixe .. 29 format libre .25, 27

Fortran

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

documentation ..19 fortran 2003 . 13 fortran 2008 . 13 fortran 66 11 fortran 77 11 fortran 90 13 fortran 95 13 fortran IV 11 fortran V . 11 Fortran 95 ..15, 45, 55, 89, 115, 117, 137, 145, 209, 211, 213, 233, 235, 245, 255 fraction . 243

–    G –

générique interface .183

gather - scatter .77 GET_COMMAND .. 237 GET_COMMAND_ARGUMENT 239 GET_ENVIRONMENT_VARIABLE .239 global - local .. 165

–    H –

host association . 51, 125 huge .243

–    I –

iachar 251 iand . 255 ibclr . 255 ibits . 255 IBM/SP6 .. 257 ibset .255 ichar .251 identificateur 25 ieor ..255 if - then - else .. 59 implicit none .. 165 index 253

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

index - fonction .. 117 initialisation 117 initialisation-expression . 117 INPUT_UNIT .225 inquire ..227 int - fonction ..117 INT16 35

INT32 35

INT64 35 INT8 . 35 intent . 15, 31, 161, 163, 171, 197, 201, 291 interface 281 interface assignment . 199, 211, 215, 289 interface explicite ..83, 123, 161, 163, 167, 171 obligatoire ..177

interface générique .183, 187 interface implicite 159 interface operator . 197, 199, 209, 289 internes procédures . 163, 165, 167

internes - procédures ..23 intrinsic .. 31 iolength .227 iomsg= read ..231

ior 255 iostat 61, 63, 229, 275, 277, 279, 281 iostat= read ..231 IOSTAT_END 225 IOSTAT_EOR 225 ishft . 255 ishftc 255 ISO_FORTRAN_ENV ..225

– K –

KIND 33, 35 kind ..15, 35, 117, 257, 259, 281, 313

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

–    L –

lbound 87 len_trim ..253, 275, 277, 279, 281 lge 253 lgt 253 ligne de commande arguments ..241

linéariser 107 liste chaînée .. 55, 157 lle 253 llt 253 local - global .. 165 logiques opérateurs 27

–    M –

méthodes .. 209 makedepf90 269 makefile .269 mask fonctions tableaux ..89

masque .. 89, 93, 95, 113 matmul 95, 97, 119 matrice tridiagonale . 109 maxloc 89 maxval . 93, 119 merge .. 111 méthodes .. 205 minloc 89 minval 93 module procedure . 183, 197, 199, 209 modules .. 15, 23, 171, 183, 197, 205, 215, 289 mot-clé .. 25 mots-clé 171 arguments ..163 MOVE_ALLOC 131, 133 mvbits .. 255

–    N –

namelist 233

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

nearest ..243 NEC-SX8 23 NEC/SX8 ..259 Norme 2003 125 norme 2003 . 47 norme 2008 .67, 69 Norme 95 .. 125 not .. 255 null ..15, 137, 145, 157, 209 nullify .. 145, 149, 211 NUMERIC_STORAGE_SIZE .. 35

– O –

opérateur

(nouvel) .197

open .227 action 227 delim .227 pad .. 227 position . 227 status 227

operateur opérateurs logiques .27 surcharge 195

optional 15, 31, 161, 163, 171, 187 order ..99 OUTPUT_UNIT . 225

– P –

pack 107, 109, 119, 275, 277 pad 13, 99, 227 open . 227

parameter 31, 33, 55, 171 pointer . 31, 55, 137, 289 champ de structure 55

pointeur état nul .143, 145, 147 descripeur .. 137 opérateur = 141

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

récursivité .. 157

pointeurs .. 55, 137, 155, 157, 215 alias ..137 tableaux ..55

position open . 227

précision .37, 39 precision 243 précision . 41 present 15, 161, 171, 187 private .31, 205, 207, 289 procédural argument 179

procédures internes .. 165 product 95, 119 profil 71, 73, 77, 87, 97, 171 public 31, 205, 207 pure ..15, 309, 311

– R –

réallocation et affectation automatique . 131 réallocation via affectation . 129 récursif . 221 récursivité pointeur .157

random_number .245, 271, 273 random_seed 245, 271 rang .71, 73, 75, 77, 87, 155 range .. 41, 243 real - fonction .117 REAL128 35 REAL32 ..35 REAL64 ..35 recl ..227 récursif 15 recursive 221 repeat .. 253 reshape 75, 97, 105, 107, 109, 111, 117, 119, 199, 271, 273, 275, 281 result 221 RS/SP6 ..23

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

– S –

save .. 13, 31, 33, 125 scalaire

ALLOCATABLE .. 129

scan . 253 scatter - gather .77 scoping unit 165 sections de tableaux - procédures .. 83 sections irrégulières 79 sections régulières . 77 select case 15, 67, 291 selected_int_kind 39, 117 selected_real_kind 39, 117, 313 sequence 51, 55 shape 87, 119, 215, 273, 275 sign ..243 size .. 81, 87, 117, 119, 123, 273, 281 size= read ..229

sous-types 35 spacing . 243 specification part : module . 165 specification-expression . 121 spread ..109, 111, 273 static . 33 status open . 227

structure . 23, 45, 215 structures de contrôle

SELECT CASE . 65

sum . 95, 97, 119, 275 surcharge 15 surcharge d’opérateurs . 73, 195 SX8-NEC 23 sxf90 : cross-compilateur NEC ..23 system_clock 245, 247

– T –

tableau

constructeur . 75

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

pointeurs 151 profil différé 155 sections non régulières .85

tableaux automatiques .. 123 conformants .71, 73 dynamiques .123 profil différé 123 profil implicite .. 83 sections .. 77 sections irrégulières 79 taille implicite 81

tableaux automatiques ..123 tableaux dynamiques ..123, 125 taille . 71, 73, 81, 87, 171 target . 55, 125, 139, 289 tests

SELECT CASE . 65

time . 245 tiny ..243 trace - matrice . 119, 275 traceback .. 215 transfer 117, 251, 277 transpose ..111, 119, 201 tri 151 trim .. 117, 253 type dérivé 45, 283 composante ALLOCATABLE .. 127 constructeur . 47

type dérivé et E./S. 53 type dérivé semi-privé 207 types . 29

– U –

ubound .. 87 unpack 107, 109 use 23, 125, 167, 197, 199, 205 clause only . 217

use association .51, 125, 177

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314

Annexe C : apports de la norme 95

Le « bloc FORALL »

–    V –

vecteurs d’indices ..79 verify 253 vocation arguments 161, 163

–    W –

what ..23 where . 15, 113, 115, 315 while - do while 61

–    Z –

zéro positif/négatif .. 243

Patrick Corde Hervé Delouis ( )

Langage Fortran(Avancé)

                                    26 juin 2017              314 / 314



112