Langage Fortran (Avancé) - idris.fr ?· Fortran 90 explained,SciencePublications,Oxford,1994,(294pages),…

Download Langage Fortran (Avancé) - idris.fr ?· Fortran 90 explained,SciencePublications,Oxford,1994,(294pages),…

Post on 30-Jul-2018

212 views

Category:

Documents

0 download

TRANSCRIPT

  • Langage Fortran(Avanc)

    Patrick CordeHerv Delouis

    Patrick.Corde@idris.fr

    4 juillet 2018

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 1 / 317

    Table des matires I

    1 IntroductionHistoriqueCompatibilit norme 77/90Apports de Fortran 90Apports de Fortran 95bibliographiedocumentation

    2 GnralitsStructure dun programmeCompilation, dition des liens, excutionlments syntaxiques

    Les identificateursLe format libre Les commentairesLe format fixe Les dclarationsTypage des donnes : paramtre KINDTypage des donnes : paramtre KIND (nouveauts norme 2008)

    3 Types drivsDfinition et dclaration de structuresInitialisation (constructeur de structure)Constructeur de structure : norme 2003Symbole % daccs un champTypes drivs et procdures

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 2 / 317

  • Table des matires II

    Types drivs et entres/sorties4 Programmation structure

    IntroductionBoucles DOLe bloc SELECT-CASELa structure block

    5 Extensions tableauxDfinitions (rang, profil, tendue, ...)Manipulations de tableaux (conformance, constructeur, section, taille, ...)Initialisation de tableauxSections de tableauxSections irrguliresTableau en argument dune procdure (taille et profil implicites)Section de tableau non contigu en argument dune procdureFonctions intrinsques tableaux

    Interrogation (maxloc, lbound, shape, ...)Rduction (all, any, count, sum, . . . )Multiplication (matmul, dot_product, . . . )Construction/transformation (reshape, cshift, pack, spread, transpose, . . . )

    Instruction et bloc WHEREExpressions dinitialisationExemples dexpressions tableaux

    6 Gestion mmoireExpressions de spcification

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 3 / 317

    Table des matires III

    Tableaux automatiquesTableaux dynamiques ALLOCATABLE, profil diffrArgument muet ALLOCATABLE : norme 2003Composante allouable dun type driv : norme 2003Allocation dun scalaire ALLOCATABLE : norme 2003Allocation/rallocation via laffectation : norme 2003Procdure MOVE_ALLOC de rallocation : norme 2003

    7 PointeursDfinition, tats dun pointeurDclaration dun pointeurSymbole =>Symbole = appliqu aux pointeursAllocation dynamique de mmoireImbrication de zones dynamiquesFonction NULL() et instruction NULLIFYFonction intrinsque ASSOCIATEDSituations viterDclaration de tableaux de pointeurs Passage dun pointeur en argument de procdurePassage dune cible en argument de procdurePointeur, tableau profil diffr et COMMONListe chane

    8 Interface de procdures et modulesPatrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 4 / 317

  • Table des matires IV

    Interface implicite : dfinitionInterface implicite : exempleArguments : attributs INTENT et OPTIONALPassage darguments par mot-clInterface explicite : procdure interneInterface explicite : 5 possibilitsInterface explicite : bloc interfaceInterface explicite : ses apportsInterface explicite : module et bloc interfaceInterface explicite : module avec procdureCas dinterface explicite obligatoireArgument de type procdural et bloc interface

    9 Interface gnriqueIntroductionExemple avec module procedureExemple : contrle de procdure F77

    10 Surcharge ou cration doprateursIntroductionInterface operatorInterface assignment

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiquesIntroductionInstructions PRIVATE et PUBLIC

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 5 / 317

    Table des matires V

    Attributs PRIVATE et PUBLICType driv semi-privExemple avec contrle de la visibilitParamtre ONLY de linstruction USE

    12 Procdures rcursivesClauses RESULT et RECURSIVEExemple : suite de Fibonacci

    13 Nouveauts sur les E/SAccs aux fichiers pr-connectsOPEN (status, position, pad, action, delim)INQUIRE (recl, action, iolength,...)Entres-sorties sur les fichiers texte (advance=no)Paramtres IOSTAT et IOMSG de linstruction READParamtres IOSTAT et IOMSG de linstruction READInstruction NAMELISTSpcification de format minimum

    14 Nouvelles fonctions intrinsquesAccs lenvironnement, ...Prcision/codage numrique : tiny/huge, sign, nearest, spacing, ...Mesure de temps, date, nombres alatoiresTransformation (transfer)Conversion entiers/caractres (char, ichar, ...)Comparaison de chanes (lge, lgt, lle, llt)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 6 / 317

  • Table des matires VI

    Manipulation de chanes (adjustl, index, ...)Oprations sur les bits (iand, ior, ishft, ...)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 7 / 317

    Introduction

    1 IntroductionHistoriqueCompatibilit norme 77/90Apports de Fortran 90Apports de Fortran 95bibliographiedocumentation

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 8 / 317

  • Introduction

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 9 / 317

    Introduction Historique

    Code machine (notation numrique en octal) ; Assembleurs de codes mnmoniques ; 1954 : projet cration du premier langage

    symbolique FORTRAN par John Backus dIBM (Mathematical FORmulaTRANslating System) :

    Efficacit du code gnr (performance) ; Langage quasi naturel pour scientifiques (productivit, maintenance, lisibilit).

    1957 : Livraison des premiers compilateurs ; 1958 : Fortran II (IBM) sous-programmes compilables de faon indpendante. Gnralisation aux autres constructeurs mais :

    divergences des extensions ncessit de normalisation ; ASA American Standards Association (ANSI American Nat. Standards Institute).

    Comit charg du dveloppement dune norme Fortran. 1966 : Fortran IV (Fortran 66) ; volution par extensions divergentes. . . 1977 : Fortran V (Fortran 77).quasi compatible :aucune itration des boucles nulles (DO I=1,0)

    Nouveauts principales : type caractre ; IF-THEN-ELSE ; E/S accs direct et OPEN.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 10 / 317

  • Introduction Historique

    Travail des comits X3J3/ANSI et WG5/ISO pour moderniser Fortran 77 : Standardisation : inclusion dextensions ; Dveloppement : nouveaux concepts dj exploits par langages plus rcents 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 ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 11 / 317

    Introduction Compatibilit norme 77/90

    Compatibilit norme 77/90

    La norme 77 est totalement incluse dans la norme 90. Quelques comportements diffrents :

    beaucoup plus de fonctions/sous-progr. intrinsques risque dhomonymie avecprocdures externes Fortran 77 et donc de rsultats diffrents ! EXTERNAL recommandpour les procdures externes non intrinsques,

    attribut SAVE automatiquement donn aux variables initialises par linstruction DATA(en Fortran 77 ctait constructeur dpendant ) ;

    E/S - En lecture avec format, si Input list > Record length (ou plus exactement si unefin denregistrement est atteinte avant la fin de lexploration du format associ lavalorisation de linput list) :

    OK en Fortran 90 car au niveau de lOPEN, PAD="YES" pris par dfaut. Erreur en Fortran 77 !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 12 / 317

  • Introduction Apports de Fortran 90

    Apports de Fortran 90

    Procdures internes (CONTAINS), modules (USE) ; Format libre , identificateurs, dclarations ; Prcision des nombres : KIND portabilit ; Objets de types drivs ; DOEND DO, SELECT CASE, WHERE ; Extensions tableaux : profil, conformance, manipulation, fonctions ; Allocation dynamique de mmoire (ALLOCATE) ; Pointeurs ; Arguments : OPTIONAL, INTENT, PRESENT. Passage par mot-cl ; Bloc interface, interface gnrique, surcharge doprateurs ; Procdures rcursives ; Nouvelles fonctions intrinsques ; Normalisation directive INCLUDE.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 13 / 317

    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 317).

    Les attributs PURE et ELEMENTAL pour des procdures sans effet de bord et pour lesecond des arguments muets lmentaires mais appel possible avec arguments detype tableaux(cf. Annexe C pages 313, 315).

    Fonction intrinsque NULL() pour forcer un pointeur ltat nul y compris lors de sadclaration (cf. chap. 7 page 147).

    Libration automatique des tableaux dynamiques locaux nayant pas lattribut SAVE(cf. chap. 6 page 125).

    Valeur initiale par dfaut pour les composantes dun type driv(cf. chap. 3 page 55).

    Fonction intrinsque CPU_TIME (cf. chap. 14 page 247). Bloc WHERE : imbrication possible (cf. chap. 5 page 115). Expressions dinitialisation tendues (cf. chap. 5 page 117). MAXLOC/MINLOC : ajout argument dim (cf. Chap. 5 page 89). Ajout generic_spec (cf. Chap. 9 page 189) au niveau delinstruction END INTERFACE [generic_spec]

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 14 / 317

  • Introduction bibliographie

    bibliographie

    Adams, Brainerd, Hendrickson, Maine, Martin, Smith, The Fortran 2003Handbook, 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 spcificits 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 ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 15 / 317

    Introduction bibliographie

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

    Lignelet P., Fortran 90 : approche par la pratique, ditions Studio Image(srie informatique), 1993, ISBN 2-909615-01-4 ;

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

    Lignelet P., Structures de donnes et leurs algorithmes avec Fortran 90 etFortran 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 franaise par Pichon B. et Caillat M.,Fortran 90 : les concepts fondamentaux, ditions AFNOR, 1993, ISBN2-12-486513-7 ;

    Fortran 95/2003 explained, Oxford University Press, 2004, (416 pages),ISBN 0-19-852693-8 ;

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 16 / 317

  • Introduction bibliographie

    Olagnon Michel, Traitement de donnes numriques 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 auprs de lAFNOR.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 17 / 317

    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 ladresse :http://www.idris.fr/turing/doc-ibm.html

    Documentation gnrale Supports de cours Fortran 95 IDRIS :

    http://www.idris.fr, choix Supports de cours puis Fortran The Fortran Company :

    http://www.fortran.com tat davancement de lintgration de la norme Fortran 2003 :

    http://fortranwiki.org/fortran/show/Fortran+2003+status tat davancement de lintgration de la norme Fortran 2008 :

    http://fortranwiki.org/fortran/show/Fortran+2008+status

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 18 / 317

    http://www.idris.fr/turing/doc-ibm.htmlhttp://www.idris.frhttp://www.fortran.comhttp://fortranwiki.org/fortran/show/Fortran+2003+statushttp://fortranwiki.org/fortran/show/Fortran+2008+status

  • Gnralits

    1 Introduction

    2 GnralitsStructure dun programmeCompilation, dition des liens, excutionlments syntaxiques

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 19 / 317

    Gnralits

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 20 / 317

  • Gnralits Structure dun programme

    Structure dun programme

    CONTAINS

    CONTAINS

    CONTAINS

    CONTAINS

    USE

    USE

    Sousprogramme

    Fonction

    Procedureinterne

    Fonction

    PartiePrivee

    Sousprogramme

    Programme principal Module

    PartiePublique

    Fonction

    Procedure interne

    Procedure interne

    Sousprogramme

    interneProcedure

    Procedure interne

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 21 / 317

    Gnralits Compilation, dition des liens, excution

    Compilation, dition des liens, excution

    Le compilateur cre pour chaque fichier source : un fichier objet de mme nom suffix par .o, autant de fichiers nom_module.mod quil 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) dautres modules, ces derniers doivent avoir tprcdemment compils.

    1 Compilation pralable 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 trouvssils se trouvent dans le rpertoire courant ou dans celui du source. Loption -Ipermet de spcifier dautres rpertoires de recherche prioritaires.

    3 Excution : a.out

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 22 / 317

  • Gnralits lments syntaxiques

    Les identificateurs

    Un identificateur est form dune suite de caractres choisis parmi les lettres (nonaccentues), les chiffres et le blanc soulign. Le premier dentre eux doit treobligatoirement une lettre.La longueur dun identificateur est limite 63 caractres.On ne distingue pas les majuscules des minuscules.

    Attention : en format libre , les blancs sont significatifs.

    Exemple didentificateurs

    compteur Compteur fin_de_fichier montant_annee_1993

    En Fortran il existe un certain nombre de mots-cls (real, integer, logical, . . .),mais qui ne sont pas rservs comme dans la plupart des autres langages. On peut donc,dans labsolu, les utiliser comme identificateurs personnels. Cependant, pour permettreune bonne lisibilit du programme on vitera de le faire.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 23 / 317

    Gnralits lments syntaxiques

    Le format libre

    1 Dans le mode format libre les lignes peuvent tre de longueur quelconque concurrence de 132 caractres ;

    2 Il est galement possible de coder plusieurs instructions sur une mme ligne en lessparant avec le caractre ; ;

    3 Une instruction peut tre code sur plusieurs lignes : on utilisera alors le caractre & ;

    4 Lors de la coupure dune constante chane de caractres la suite de la chane doitobligatoirement tre prcde du caractre & .

    Exemples

    print *, " Entrez une valeur :"; read *,nprint *, "Montant HT :", montant_ht , &

    " TVA :", tva , &"Montant TTC :", montant_ttc

    print *, "Entrez un nombre entier &&compris entre 100 & 199"

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 24 / 317

  • Gnralits lments syntaxiques

    Les commentaires

    Le caractre ! rencontr sur une ligne indique que ce qui suit est un commentaire. Onpeut videmment crire une ligne complte de commentaires : il suffit pour cela que le1er caractre non blanc soit le caractre ! .

    Exemple

    if (n < 100 .or. n > 199) then ! Test cas derreur. . . .

    ! On lit lexposantread *,x! On lit la baseread *,yif (y .NE. /=

    Les oprateurs .AND., .OR., .NOT. ainsi que .EQV. et .NEQV. nont pas dquivalentsnouveaux.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 25 / 317

    Gnralits lments syntaxiques

    Par contre, il nest pas possible dinsrer un commentaire entre deux instructions situessur une mme ligne. Dans ce cas la 2e instruction ferait partie du commentaire.

    Exemple

    i=0 ! initialisation ; j = i + 1

    Attention :C----- Commentaire Fortran 77c----- Commentaire Fortran 77*----- Commentaire Fortran 77

    ne sont pas des commentaires Fortran en format libre et gnrent des erreurs decompilation.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 26 / 317

  • Gnralits lments syntaxiques

    Le format fixe

    Le format fixe de Fortran correspond lancien format du Fortran 77 avec deuxextensions :

    plusieurs instructions possibles sur une mme ligne ; nouvelle forme de commentaire introduite par le caractre ! .

    Son principal intrt est dassurer la compatibilit avec Fortran 77. Cest un aspectobsolte du langage !

    Structure dune 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 ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 27 / 317

    Gnralits lments syntaxiques

    Les dclarations

    Dclarer une variable permet notamment de lui attribuer un type. De mme que lancienFortran un type par dfaut est appliqu aux variables non dclares. Il est vivementrecommand de spcifier linstruction IMPLICIT NONE en tte de toute unit deprogramme pour tre dans lobligation de les dclarer. La syntaxe dune dclaration est lasuivante :

    type[, liste_attributs :: ] liste_identificateurs

    Liste des diffrents types :

    real integer double precision complex character logical type

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 28 / 317

  • Gnralits lments syntaxiques

    Diffrents attributs :

    parameter constante symboliquedimension taille dun tableauallocatable objet dynamiquepointer objet dfini comme pointeurtarget objet accessible par pointeur (cible)save objet statiqueintent vocation dun argument muetoptional argument muet facultatifpublic ou private visibilit dun objet dfini dans un moduleexternal ou intrinsic nature dune procdure

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 29 / 317

    Gnralits lments syntaxiques

    Exemple de dclarations

    integer nbre , cumulreal x, y, zinteger , save :: compteurinteger , parameter :: n = 5double precision a(100)double precision , dimension (100) :: acomplex , dimension (-2:4, 0:5) :: creal , pointer , dimension (:) :: ptrreal , pointer :: ptr(:) ! non recommand : pourrait tre interprt

    ! tort comme un tableau de pointeurs.

    Note : il est toujours possible de donner le type et les diffrents attributs dun objet laide de plusieurs instructions, mais on prfrera la dernire syntaxe :

    Exemple

    integer tabdimension tab (10)save tab

    integer , dimension (10), save :: tab

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 30 / 317

  • Gnralits lments syntaxiques

    Il est possible dinitialiser un objet au moment de sa dclaration. Cest dailleursobligatoire si lattribut parameter est spcifi.

    Exemple

    character(len=4), dimension (5) :: notes = &(/ "do# ","re ","mi ","fa# ","sol#" /)

    integer ,dimension (3) :: t_entiers =(/ 1, 5, 9 /)

    Remarques en Fortran 77 toute variable initialise (via linstruction DATA) nest permanenteque si lattribut save a t spcifi pour cette variable, ou bien si la compilation at faite en mode static ;

    depuis la norme Fortran 90 toute variable initialise est permanente : elle reoitlattribut save implicitement ;

    la norme Fortran 2008 prcise que toute variable dclare (avec ou sansinitialisation) au sein de lunit de programme principale ou dun module reoitlattribut save implicitement.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 31 / 317

    Gnralits lments syntaxiques

    Typage des donnes : paramtre KIND

    Les types prdfinis en Fortran (depuis la norme 90) sont des noms gnriques renfermantchacun un certain nombre de variantes ou sous-types que lon peut slectionner laide duparamtre KIND lors de la dclaration des objets. Ce paramtre est un mot-cl valeur entirequi dsigne la variante souhaite pour un type donn.

    Remarques les diffrentes valeurs du paramtre KIND sont dpendantes du systme utilis. Elles

    correspondent, en gnral, au nombre doctets dsirs pour coder lobjet dclar ; chaque type correspond une variante par dfaut, slectionne en labsence du paramtre

    KIND : cest la simple prcision pour les rels.(Voir tableau en annexe A page 261) ;

    concernant les chanes de caractres, cette valeur peut indiquer le nombre doctets utilisspour coder chaque caractre :

    2 octets seront ncessaires pour coder les idogrammes des alphabets chinois oujaponais ;

    1 seul octet suffit pour coder les caractres de notre alphabet.

    Exemple

    real(kind =8) 1 x ! gnralement la double prcision.integer(kind =2) 1, target , save :: i

    1. cette syntaxe remplace celle utilise en Fortran 77 : real8, integer2Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 32 / 317

  • Gnralits lments syntaxiques

    Typage des donnes : paramtre KIND (nouveauts norme 2008)

    La norme 2008 a dfini un module (ISO_FORTRAN_ENV) renfermant diverses constantessymboliques facilitant la dclaration des donnes de type intrinsque (prcision du gabaritmmoire, variantes disponibles, ...) :

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

    2 INT8, INT16, INT32 et INT64 permettent de prciser le gabarit (8, 16, 32, 64 bits) dunentier ;

    3 REAL32, REAL64 et REAL128 permettent de prciser le gabarit (32, 64, 128 bits) dun rel ;4 NUMERIC_STORAGE_SIZE est la valeur en bits dune donne dclare de type INTEGER, REAL

    ou LOGICAL par dfaut, c--d sans spcification du paramtre KIND (32 gnralement) ;5 CHARACTER_STORAGE_SIZE est la valeur en bits dune donne dclare de type CHARACTER

    (8 gnralement).Remarques

    toute unit de programme devra comporter linstruction use ISO_FORTRAN_ENV pouraccder ces constantes ;

    dans le cas o la taille demande nest pas disponible pour le compilateur utilis, laconstante correspondante renfermera la valeur -2 si une taille suprieure est disponible, -1sinon.

    Exemple

    use ISO_FORTRAN_ENVreal(kind=REAL64) :: x ! rel sur 64 bits.integer(kind=INT64) :: i ! entier sur 64 bits.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 33 / 317

    Gnralits lments syntaxiques

    On a la possibilit dindiquer le sous-type dsir lors de lcriture des constantes.Il suffira, pour cela, de les suffixer (pour les constantes numriques) ou de les prfixer(pour les constantes chanes de caractres) par la valeur du sous-type voulu en utilisantle caractre _ comme sparateur.

    Exemple

    23564 _4 ! INTEGER(KIND=4)12.879765433245 _8 ! REAL(KIND=8)12.879765433245 _REAL64 ! REAL(KIND=REAL64) (depuis la norme 2008)1_"wolfy" ! CHARACTER(LEN=5,KIND=1)2_"wolfy" ! CHARACTER(LEN=5,KIND=2)integer(kind=short), parameter :: kanji = 2kanji_"wolfy" ! CHARACTER(LEN=5,KIND=kanji)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 34 / 317

  • Gnralits lments syntaxiques

    Fonction KIND

    Cette fonction renvoie une valeur entire qui correspond au sous-type de largumentspcifi.

    Exemples

    ! Valeur associe au sous -type rel simple prcision :kind(1.0)

    ! Valeur associe au sous -type rel double prcision :kind(1.0d0)

    ! La dcalaration suivante permet de dclarer un rel! double prcision quelle que soit la machine utilise :real(kind=kind(1.d0))

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 35 / 317

    Gnralits lments syntaxiques

    Exemple

    program pdouble precision dreal r

    r = 2.718call sp( real(r, kind(d)), d )

    ...end program p!-----------------------------------subroutine sp( x, y )

    double precision x, y

    y = x*xend subroutine sp

    Remarque : les types dfinis via cette fonction KIND sont assurs dtre portables auniveau de la compilation.Les fonctions SELECTED_REAL_KIND et SELECTED_INT_KIND vues ci-aprs vont plus loinen assurant la portabilit au niveau de lexcution (sauf impossibilit matrielle dtecte la compilation).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 36 / 317

  • Gnralits lments syntaxiques

    Fonctions intrinsques SELECTED_INT_KIND, SELECTED_REAL_KIND

    Elles ont pour prototype :

    SELECTED_INT_KIND(r), SELECTED_REAL_KIND(p,r)

    La premire reoit un nombre entier r en argument et retourne une valeur qui correspondau sous-type permettant de reprsenter les entiers n tels que :

    10r < n < 10r

    Elle retourne -1 si aucun sous-type ne rpond la demande.La deuxime admet deux arguments p et r indiquant respectivement la prcision(nombre de chiffres dcimaux significatifs) et ltendue (range) dsires. Elle retourne unentier (kind) qui correspond au sous-type permettant de reprsenter les rels xrpondant la demande avec :

    10r

  • Gnralits lments syntaxiques

    Exemple

    integer ,parameter :: prec = selected_real_kind(p=9,r=50)integer ,parameter :: iprec = selected_int_kind(r=2)

    integer(kind=iprec) :: k=1 _iprecreal(kind=prec), save :: xreal(prec), save :: yx = 12.765 _prec

    ...selected_int_kind (30) ! Impossible -> -1selected_real_kind (8)selected_real_kind (9, 99)selected_real_kind(r=50)

    noter que la prcision et ltendue peuvent tre values en utilisant les fonctionsPRECISION et RANGE vues ci-aprs.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 39 / 317

    Gnralits lments syntaxiques

    Fonctions intrinsques RANGE et PRECISION

    Pour le sous-type de largument entier ou rel fourni, la fonction RANGE retourne lavaleur entire maximale de lexposant dcimal r telle que tout entier ou rel satisfaisant :

    |entier | < 10r

    10r < |rel| < 10r

    est reprsentable.

    La fonction PRECISION retourne la prcision dcimale (nombre maximum de chiffressignificatifs dcimaux mantisse) pour le sous-type de largument rel fourni.

    Exemples Cray C90 Machines IEEErange(1_4) 9 9range(1_8) 18 18range(1.0) 2465 37precision(1.0) 13 6range(1.d0) 2465 307precision(1.d0) 28 15

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 40 / 317

  • Types drivs

    1 Introduction

    2 Gnralits

    3 Types drivsDfinition et dclaration de structuresInitialisation (constructeur de structure)Constructeur de structure : norme 2003Symbole % daccs un champTypes drivs et procduresTypes drivs et entres/sorties

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 41 / 317

    Types drivs

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 42 / 317

  • Types drivs Dfinition et dclaration de structures

    Tableau : objet regroupant des donnes de mme type repres par un/des indicesnumriques.

    Ncessit de dfinir un objet composite (structure de donnes) regroupant desdonnes (champs ou composantes) htrognes. Chaque champ est identifi parson nom. Sa dclaration ncessite la dfinition pralable du type driv tendant lestypes prdfinis.

    Exemple: manipuler des couleurs en composantes additives RVB

    1 Dfinition du type driv COULEUR :type COULEUR

    character(len =25) :: nominteger , dimension (3) :: code_rvb

    end type COULEUR

    Norme 95 : possibilit dinitialisation des champs.

    2 Dclaration du tableau TABRVB des 3 couleurs de base et initialisation :type(COULEUR),dimension (3), parameter :: TABRVB = &

    (/ couleur("Rouge", (/ 255,0,0 /)), &couleur("Vert ", (/ 0,255,0 /)), &couleur("Bleu ", (/ 0,0,255 /)) /)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 43 / 317

    Types drivs Initialisation (constructeur de structure)

    Initialisation (constructeur de structure)

    Dans lexpression : (/ couleur(Rouge, (/ 255,0,0 /) ),&...

    bien distinguer :1 notion de constructeur de structure (Structure Constructor) :fonction (ici couleur) de mme nom que le type driv ayant pour arguments lesvaleurs placer dans les divers champs. Automatiquement cre, elle permetlinitialisation ou laffectation globale dune structure de donnes ;

    2 notion de constructeur de tableau (Array Constructor) :agrgat vectoriel (squence de valeurs scalaires sur une seule dimension) dlimit parles caractres (/ et /) (ou bien [ et ] depuis la norme 2003)permettant linitialisation ou laffectation globale dun tableau de rang 1.

    Exemple

    integer , dimension (3) :: TJtype(couleur), dimension (5) :: TC

    TC(1) = couleur( "Gris souris", (/ 158, 158, 158 /) )TC(2) = couleur( "Gris anthracite", [ 48, 48, 48 ] )TJ = [ 255, 255, 0 ]TC(3) = couleur( "Jaune",TJ )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 44 / 317

  • Types drivs Initialisation (constructeur de structure)

    Constructeur de structure : norme 2003

    depuis la norme 95 il est permis de prciser une valeur pour une composante lors dela dfinition du type ;

    lors de la valorisation dun type driv via un constructeur de structure, la norme2003 permet dsormais daffecter les composantes par mots cls ;

    si une composante dun type driv une valeur par dfaut, largumentcorrespondant au niveau du constructeur se comporte comme un argumentoptionnel.

    Exemple

    type couleurcharacter(len =25) :: nom = noirinteger , dimension (3) :: code_rvb = [ 0, 0, 0 ]

    end type couleur...

    type(couleur) :: c...

    c = couleur( nom="Saumon", code_rvb =[ 248, 142, 85 ] )...

    c = couleur( code_rvb =[ 249, 66, 158 ], nom="Rose bonbon" )...

    c = couleur ()

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 45 / 317

    Types drivs Initialisation (constructeur de structure)

    Constructeur de structure : norme 2003

    Remarques

    pour une composante comportant lattribut pointer, cest une association (au sensdu symbole => ) qui seffectuera avec largument prcis au niveau duconstructeur. On pourra indiquer la fonction NULL pour forcer la composante ltatnul de faon explicite ;

    pour une composante comportant lattribut allocatable, largument prcis auniveau du constructeur devra tre de mme type et de mme rang. Sil a lattributallocatable, il peut tre ou non allou. Comme pour une composante pointer, onpourra prciser la fonction NULL mais sans argument : la composante sera alors dansltat "non allou".

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 46 / 317

  • Types drivs Symbole % daccs un champ

    Symbole % daccs un champ

    Le symbole % permet daccder un champ dune structure de donne. Voiciquelques exemples :

    TC tableau de structures de donnes de type driv 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 entits encadrant lesymbole % doit tre un scalaire (rang nul) sachant quune structure est considrecomme 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, loprande de droite nedoit pas avoir lattribut pointer ni allocatable !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 47 / 317

    Types drivs Symbole % daccs un champ

    Symbole % daccs un champ

    Supposons que nous voulions stocker dans TC(4) la couleur jaune sous la forme(Rouge + Vert) ; il serait tentant de le faire de la faon suivante :

    TC(4) = tabrvb(1) + tabrvb(2)

    Cette instruction ne serait pas valide car si le symbole daffectation (=) est bien surchargpar dfaut pour sappliquer automatiquement aux structures de donnes, il nen est pasde mme de loprateur daddition (+). Comme nous le verrons plus loin, seulelaffectation ayant un sens par dfaut, la surcharge ventuelle doprateurs poursappliquer des oprandes de type driv est possible mais la charge du programmeur.Voil pourquoi nous devons oprer au niveau des composantes de ces structures enutilisant le symbole %.

    Exemple de nouvelle dfinition (couleur jaune)

    TC(4)= &couleur("jaune", (/ tabrvb (1)% code_rvb (1) + tabrvb (2)% code_rvb (1), &

    tabrvb (1)% code_rvb (2) + tabrvb (2)% code_rvb (2), &tabrvb (1)% code_rvb (3) + tabrvb (2)% code_rvb (3) /))

    ou plus simplement :TC(4)= couleur( "Jaune", tabrvb (1)% code_rvb + tabrvb (2)% code_rvb )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 48 / 317

  • Types drivs Types drivs et procdures

    Types drivs et procdures

    Une structure de donnes peut tre transmise en argument dune procdure et unefonction peut retourner un rsultat de type driv.Si le type driv nest pas visible (par use association depuis un module ou par hostassociation depuis la procdure hte), il doit tre dfini la fois (situation viter) danslappel et lappelant. Les deux dfinitions doivent alors :

    possder toutes les deux lattribut SEQUENCE stockage des champs avec mmeordre et mmes alignements en mmoire ;

    tre identiques. Le nom du type et celui de la structure peuvent diffrer mais pas lenom et la nature des champs.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 49 / 317

    Types drivs Types drivs et procdures

    Types drivs et procdures

    Exemple 1

    type(COULEUR) :: demi_teinte ! Obligatoire ici !...

    TC(5) = demi_teinte(TC(1))...

    function demi_teinte(col_in)implicit none!-----------------------------------------------type COLOR !

  • Types drivs Types drivs et procdures

    Exemple 2

    program geom3dimplicit noneinteger ireal pstype VECTEUR

    real x,y,zend type VECTEURtype CHAMP_VECTEURS ! >>>> Types imbriqus

    integer n ! Nb. de vecteurstype(VECTEUR),dimension (20) :: vect ! 20 : taille max.

    end type CHAMP_VECTEURS!-------------------------Dclarations --------

    type(VECTEUR) :: u,v,wtype(CHAMP_VECTEURS) :: champ

    !----------------------------------------------u=vecteur (1. ,0. ,0.) !>>> Construct. struct.w=u !>>> Affectation

    ! champ=u !>>> ERREUR! if(u==v) then !>>> ERREUR...

    ps=prod_sca(u,v)champ%n=20 ; champ%vect=[ u, v, (w,i=1,champ%n-2) ]

    containsfunction prod_sca(a,b)

    type(VECTEUR) :: a,breal :: prod_scaprod_sca=a%x*b%x + a%y*b%y + a%z*b%z

    end function prod_scaend program geom3d

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 51 / 317

    Types drivs Types drivs et entres/sorties

    Types drivs et entres/sorties

    Les entres/sorties portant sur des objets de type driv (ne contenant pas decomposante pointeur) sont possibles :

    avec format, les composantes doivent se prsenter dans lordre de la dfinition dutype et cest portable ;

    sans format, la reprsentation binaire dans lenregistrement est constructeurdpendante mme avec SEQUENCE ; non portable !

    Exemple

    type couleurcharacter(len =25) :: nom = Noirinteger , dimension (3) :: code_rvb = [ 0, 0, 0 ]

    end type couleur!-----------------------------------------------integer :: longtype(couleur), dimension (5) :: tc

    ...inquire(iolength=long) tc; print *, "tc=", tc, "long=", long

    ...write(unit=10, fmt="(5(A,3I4),I4)") tc, longwrite(unit =11) tc, long

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 52 / 317

  • Types drivs Types drivs et entres/sorties

    Remarques

    chaque champ peut tre constitu dlments de type intrinsque (real, integer,logical, character, etc.) ou dun autre type driv imbriqu ;

    lattribut PARAMETER est interdit au niveau dun champ ; linitialisation dun champ la dfinition du type nest possible que depuis lanorme 95. Un objet dun tel type, moins quil soit initialis sa dclaration, nereoit pas implicitement lattribut SAVE. Il ne peut pas figurer dans un COMMON ;

    la norme 90/95 interdit lattribut ALLOCATABLE au niveau dun champ(valide depuis la norme 2003) ;

    un objet de type driv est considr comme un scalaire mais : un champ peut avoir lattribut DIMENSION ; on peut construire des tableaux de structures de donnes.

    lattribut SEQUENCE pour un type driv est obligatoire si une structure de ce type : est passe en argument dune procdure externe au sein de laquelle une redfinition du

    type est ncessaire ; fait partie dun COMMON.

    un champ peut avoir lattribut POINTER mais pas TARGET.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 53 / 317

    Types drivs Types drivs et entres/sorties

    Remarques

    Lattribut pointer appliqu au champ dune structure permet : la dclaration de tableaux de pointeurs via un tableau de structures contenant unchamp unique ayant lattribut pointer ; cf. paragraphe Tableaux de pointeurs duchapitre 7 page 151 ;

    la gestion de listes chanes bases sur des types drivs tels :type cell

    real ,dimension (4) :: xcharacter(len =10) :: strtype(cell),pointer :: p

    end type cell

    cf. lexemple du chap. 7 page 159 et le corrig de lexercice 12 en annexe B ; lallocation dynamique de mmoire applique un champ de structure.

    noter : lors de laffectation entre 2 structures (de mme type), le compilateur raliseeffectivement des affectations entre les composantes. Pour celles ayant lattribut pointercela revient raliser une association.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 54 / 317

  • Programmation structure

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structureIntroductionBoucles DOLe bloc SELECT-CASELa structure block

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 55 / 317

    Programmation structure

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 56 / 317

  • Programmation structure Introduction

    Introduction

    Structure habituelle dun programme en blocs :

    [tiq:] IF (expression logique) THENbloc1

    [ ELSE IF (expression logique) THEN [tiq]bloc2 ]

    [ ELSE [tiq]bloc3 ]

    END IF [tiq]

    Note : ltiquette (if-construct-name) [tiq:] optionnelle peut tre utile pour clarifier desimbrications complexes de tels blocs.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 57 / 317

    Programmation structure Boucles DO

    Boucles DO

    Forme gnrale

    [tiquette :] DO [contrle de boucle]bloc

    END DO [tiquette]

    1re forme

    [tiquette :] DO variable = expr1 , expr2[,expr3]bloc

    END DO [tiquette]

    Nombre ditrations : max( expr2expr1+expr3

    expr3, 0)

    Exemple

    DO I=1,NC(I) = SUM(A(I,:)*B(:,I))

    END DO

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 58 / 317

  • Programmation structure Boucles DO

    Boucles DO

    2e forme

    DO WHILE (condition)bloc

    END DO

    Exemple

    read(unit=11, iostat=eof)a, b, cDO WHILE(eof == 0)

    . . . .

    . . . .read(unit=11, iostat=eof)a, b, c

    END DO

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 59 / 317

    Programmation structure Boucles DO

    Boucles DO

    La dernire et 3e forme sont les boucles DO sans contrle de boucle : instruction conditionnelle avec instruction EXIT dans le corps de la boucle pouren sortir.

    DOsquence 1IF (condition ) EXITsquence 2

    END DO

    Exemple

    doread(*, *) nombreif (nombre == 0) EXITsomme = somme + nombre

    end do

    Remarques cette forme de boucle (vnementielle) ne favorise gure loptimiseur ; suivant que le test de sortie est fait en dbut ou en fin, cette boucle sapparente auDO WHILE ou au DO UNTIL.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 60 / 317

  • Programmation structure Boucles DO

    Boucles DO; bouclage anticip instruction CYCLE

    Elle permet dabandonner le traitement de litration courante et de passer litrationsuivante.

    Exemple

    doread(*, *, iostat=eof)xif (eof /= 0) EXITif (x som_max) EXIT EXTER

    end doend do EXTER

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 62 / 317

  • Programmation structure Boucles DO

    Exemple 2

    B1:&do i = 1,n

    do j = 1, mcall sp(i+j, r)if (r < 0.) CYCLE B1

    end doend do B1

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 63 / 317

    Programmation structure Le bloc SELECT-CASE

    Linstruction SELECT CASE permet des branchements multiples qui dpendent de lavaleur dune expression scalaire de type entier, logique ou chane de caractres.

    [ nom_bloc: ] SELECT CASE(expression)[ CASE(liste) [ nom_bloc ]

    bloc_1]...

    [ CASE DEFAULT[ nom_bloc ]bloc_n]

    END SELECT[ nom_bloc ]

    nom_bloc est une tiquette, expression est une expression de type INTEGER, LOGICAL ou CHARACTER, liste est une liste de constantes du mme type que expression, bloci est une suite dinstructions Fortran.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 64 / 317

  • Programmation structure Le bloc SELECT-CASE

    Exemple

    PROGRAM structure_caseinteger :: mois , nb_jourslogical :: annee_bissext

    ...SELECT CASE(mois)

    CASE(4, 6, 9, 11)nb_jours = 30

    CASE(1, 3, 5, 7:8, 10, 12)nb_jours = 31

    CASE (2)!-------------------------------------

    fevrier: select case(annee_bissext)case(.true.)

    nb_jours = 29case(. false.)

    nb_jours = 28end select fevrier

    !-------------------------------------CASE DEFAULT

    print *, " Numro de mois invalide"END SELECT

    END PROGRAM structure_case

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 65 / 317

    Programmation structure La structure block

    structure block 1 : norme 2008

    La norme 2008 de Fortran permet la construction de blocs au sein desquels il est permisdeffectuer de nouvelles dclarations. Les identificateurs ne sont visibles qu lintrieur dubloc o ils sont dclars et de ceux ventuellement imbriqus ( lexception des blocsdans lesquels ces identificateurs font lobjet dune redclaration).

    Exemple

    PROGRAM structure_blockinteger ios

    ...do

    read( UNIT=1, ..., IOSTAT=ios ) ...if ( ios < 0 ) exitif ( ios > 0 ) then

    blockcharacter(len =100) :: message

    write(message , (a,i0)) &"La lecture sest interrompue &

    & suite une erreur de numro ", iosstop trim(message)

    end blockend if

    ...end do

    END PROGRAM structure_block

    1. Cette nouveaut est disponible avec les compilateurs xlf dIBM et ifort dINTEL ( partir de la version15)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 66 / 317

  • Programmation structure La structure block

    structure block : norme 2008

    La structure block peut tre tiquete comme les structures prcdentes. LinstructionEXIT rfrenant une telle structure peut rendre la programmation plus aise.

    Exemple

    PROGRAM structure_block...

    Etiq: blockdo

    if ( condition1 ) EXITif ( condition2 ) EXIT Etiq

    ...end docall sp( ... )

    end block EtiqEND PROGRAM structure_block

    Dans cet exemple on remarque que si la condition condition2 est ralise,linstruction EXIT Etiq permet de sortir de la boucle mais de plus dviter lappel laprocdure sp.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 67 / 317

    Extensions tableaux

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableauxDfinitions (rang, profil, tendue, ...)Manipulations de tableaux (conformance, constructeur, section, taille, ...)Initialisation de tableauxSections de tableauxSections irrguliresTableau en argument dune procdure (taille et profil implicites)Section de tableau non contigu en argument dune procdureFonctions intrinsques tableauxInstruction et bloc WHEREExpressions dinitialisationExemples dexpressions tableaux

    6 Gestion mmoire

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 68 / 317

  • Extensions tableaux

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 69 / 317

    Extensions tableaux Dfinitions (rang, profil, tendue, ...)

    Un tableau est un ensemble dlments du mme type.Pour dclarer un tableau, il suffit de prciser lattribut DIMENSION lors de sa dclaration :

    Exemple

    integer , dimension (5) :: tabreal(8), dimension (3,4) :: matreal , dimension (-1:3,2,0:5) :: a

    Un tableau peut avoir jusqu 7 dimensions au maximum. Le rang (rank) dun tableau est son nombre de dimensions. Le nombre dlments dans une dimension sappelle ltendue (extent) du tableaudans cette dimension.

    Le profil (shape) dun tableau est un vecteur dont chaque lment est ltendue dutableau dans la dimension correspondante.

    La taille (size) dun tableau est le produit des lments du vecteur correspondant son profil.

    Deux tableaux seront dits conformants sils ont mme profil.Attention : deux tableaux peuvent avoir la mme taille mais avoir des profils diffrents ;si cest le cas, ils ne sont pas conformants !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 70 / 317

  • Extensions tableaux Dfinitions (rang, profil, tendue, ...)

    Exemple

    real , dimension ( -5:4 ,0:2) :: xreal , dimension (0:9 , -1:1) :: yreal , dimension (2,3,0:5) :: z

    Les tableaux x et y sont de rang 2, tandis que le tableau z est de rang 3 ; Ltendue des tableaux x et y est 10 dans la 1re dimension et 3 dans la 2e. Ils ontmme profil : le vecteur (/ 10, 3 /), ils sont donc conformants. Leur taille estgale 30 ;

    Le profil du tableau z est le vecteur (/ 2, 3, 6 /), sa taille est gale 36.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 71 / 317

    Extensions tableaux Manipulations de tableaux (conformance, constructeur, section, taille, ...)

    Manipulations de tableaux (conformance, constructeur, section, taille, ...)

    Fortran 90 permet de manipuler globalement lensemble des lments dun tableau.On pourra, de ce fait, utiliser le nom dun tableau dans des expressions. En fait, plusieursoprateurs ont t sur-dfinis afin daccepter des objets de type tableau commeoprande.Il sera ncessaire, toutefois, que les tableaux intervenant dans une expression soientconformants.

    Exemple

    real , dimension (6,7) :: a,breal , dimension (2:7 ,5:11) :: cinteger , dimension (4,3) :: mlogical , dimension ( -2:3 ,0:6) :: l

    m = 1 ! Tous les lments valoriss 1.! Un scalaire est conformant tout tableau.

    b = 1.5 ! idem.c = ba = b + c + 4.l = c == b

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 72 / 317

  • Extensions tableaux Manipulations de tableaux (conformance, constructeur, section, taille, ...)

    On notera que pour manipuler un tableau globalement, on peut soit indiquer son nom,comme dans les exemples prcdents, soit indiquer son nom suivi entre parenthsesdautant de caractres : , spars par des virgules, quil a de dimensions.

    Reprise de lexemple prcdent

    real , dimension (6,7) :: a,breal , dimension (2:7 ,5:11) :: cinteger , dimension (4,3) :: mlogical , dimension ( -2:3 ,0:6) :: l

    m(:,:) = 1b(:,:) = 1.5c(:,:) = b(:,:)a(:,:) = b(:,:) + c(:,:) + 4.l(:,:) = c(:,:) == b(:,:)

    On prfrera la dernire notation la prcdente car elle a lavantage de la clart.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 73 / 317

    Extensions tableaux Initialisation de tableaux

    Initialisation de tableaux

    Il est permis dinitialiser un tableau au moment de sa dclaration ou lors dune instructiondaffectation au moyen de constructeur de tableaux.Ceci nest toutefois possible que pour les tableaux de rang 1. Pour les tableaux de rangsuprieur 1 on utilisera la fonction reshape que lon dtaillera plus loin.Un constructeur de tableau est un vecteur de scalaires dont les valeurs sont encadrespar les caractres (/ et /) .

    Exemple

    character(len=1), dimension (5) :: a = (/ "a", "b", "c", "d", "e" /)integer , dimension (4) :: t1 , t2 , t3integer :: it1 = (/ 6, 5, 10, 1 /)t2 = (/ (i*i, i=1,4) /)t3 = (/ t2(1), t1(3), 1, 9 /)

    Rappel : dans les boucles implicites , il faut autant de blocs parenthss (sparspar des virgules) quil y a dindices : (((i+j+k,i=1,3),j=1,4),k=8,24,2) noter que chaque indice est dfini par un triplet dont le troisime lment (optionnel)reprsente le pas.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 74 / 317

  • Extensions tableaux Sections de tableaux

    Sections de tableaux

    Il est possible de faire rfrence une partie dun tableau appele section de tableau ousous-tableau. Cette partie de tableau est galement un tableau. De plus le tableau, dansson intgralit, est considr comme le tableau parent de la partie dfinie. Le rang dunesection de tableau est infrieur ou gal celui du tableau parent. Il sera infrieurdautant dindices quil y en a de fixs.Il existe deux catgories de sections : les sections dites rgulires et les sectionsirrgulires.On dsigne par section rgulire un ensemble dlments dont les indices forment uneprogression arithmtique. Pour dfinir une telle section on utilise la notation par tripletde la forme val_init:val_fin:pas quivalent une pseudo-boucle.Par dfaut, la valeur du pas est 1 et les valeurs de val_init et val_fin sont les limitesdfinies au niveau de la dclaration du tableau parent. La notation dgnre sous laforme dun simple : correspond ltendue de la dimension considre.

    Exemple

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

    c(:) = a(3:10:3) !

  • Extensions tableaux Sections de tableaux

    integer , dimension (10) :: a,b,cinteger , dimension (20) :: vecinteger :: i

    a(1:9:2) = (/ (i,i=1,9,2) /)a(2:10:2) = (/ (i,i=-1,-9,-2) /)b(:) = (/ (i+1,i=1,7), a(1:3) /)c(1:5) = b(6:10)c(6:10) = a(1:5)vec (4:13) = a**2 + b**2 + c**2

    Important : la valeur dune expression tableau est entirement value avant dtre affecte.

    Ainsi pour inverser un tableau on pourra crire real, dimension(20) :: tabtab(:) = tab(20:1:-1)

    Ce qui nest pas du tout quivalent

    integer ido i=1,20

    tab(i) = tab(21-i)end do

    Note : les expressions tableaux sont en fait des notations vectorielles ce qui facilite leurvectorisation puisque contrairement aux boucles, elles vitent au compilateur lecontrle des dpendances.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 77 / 317

    Extensions tableaux Sections irrgulires

    Sections irrgulires

    Le triplet dindices ne permet dextraire quune squence rgulire dindices. Il estpossible daccder des lments quelconques par lintermdiaire dun vecteur dindices.Il sagit en fait dune indexation indirecte.

    Exemple

    integer , dimension (10 ,9) :: tabinteger , dimension (3) :: v_ind1integer , dimension (4) :: v_ind2

    v_ind1 = (/ 2,7,6 /)v_ind2 = (/ 4,1,1,3 /)tab ((/ 3,5,8 /), (/ 1,5,7 /)) = 1

    tab(v_ind1,v_ind2) est un sous-tableau indices vectoriels. On remarque quilest constitu dlments rpts. Un tel sous-tableau ne peut pas figurer gauchedun signe daffectation.

    tab(v_ind2,5) = (/ 2,3,4,5 /) nest pas permis car cela reviendrait vouloiraffecter 2 valeurs diffrentes (3 et 4) llment tab(1,5).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 78 / 317

  • Extensions tableaux Tableau en argument dune procdure (taille et profil implicites)

    Tableau en argument dune procdure (taille et profil implicites)

    Lorsque lon passe un tableau en argument dune procdure il est souvent pratique de pouvoirrcuprer ses caractristiques (taille, profil, . . . ) au sein de celle-ci.En Fortran 77 la solution tait de transmettre, en plus du tableau, ses dimensions, ce qui estvidemment toujours possible en Fortran 90.

    Exemple

    integer , parameter :: n=5,m=6integer , dimension(n,m) :: t=1call sp(t,n,m)endsubroutine sp(t,n,m)integer :: n,minteger , dimension(n,m) :: tprint *,tend

    Si le tableau dclar dans la procdure est de rang r, seules les r-1 premires dimensions sontncessaires car la dernire nintervient pas dans le calcul dadresses, do la possibilit de mettreun * la place de la dernire dimension. lexcution de la procdure les tendues dechaque dimension, hormis la dernire, seront connues mais, la taille du tableau ne ltant pas,cest au dveloppeur de sassurer quil ny a pas de dbordement. Ce type de tableau est dit taille implicite (assumed-size-array).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 79 / 317

    Extensions tableaux Tableau en argument dune procdure (taille et profil implicites)

    Reprise de lexemple prcdent

    integer , parameter :: n=5,m=6integer , dimension(n,m) :: tt = 1call sp(t,n)end

    subroutine sp(t,n)integer :: ninteger , dimension(n,*) :: tprint *,size(t,1)print *,t(:,2)print *,t(1,:) ! Interditprint *,t ! Interdit

    end

    La fonction size est une fonction intrinsque qui retourne la taille du tableau pass enargument (sauf taille implicite).Cette fonction admet un 2e argument optionnel qui permet de prciser la dimensionsuivant laquelle on dsire connatre le nombre dlments. Dans ce cas, elle retourne enfait ltendue relativement la dimension spcifie.Dans lexemple prcdent, il est possible de rcuprer ltendue de toutes les dimensionsdu tableau t lexception de la dernire.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 80 / 317

  • Extensions tableaux Tableau en argument dune procdure (taille et profil implicites)

    De plus, Fortran 90 permet de transmettre le profil du tableau pass en argument. Pourcela, il faut que linterface soit explicite (notion vue en dtails plus loin au chapitre 8) cequi permet de donner au compilateur un certain nombre de renseignements afin quilpuisse mieux vrifier la cohrence entre arguments muets et arguments dappel.

    Exemple

    program profil_impliciteinteger , dimension (5,6) :: tinterface !

  • Extensions tableaux Section de tableau non contigu en argument dune procdure

    Exemple

    program tab_sectimplicit nonereal , dimension (100 ,100) :: a1=1.0, a2real :: c1,c2,c3integer :: iinterface !----------------------!

    subroutine sub1(x) !real , dimension (:,:) :: x !

    end subroutine sub1 !end interface !----------------------!a1(3 ,2:5) = (/ 3.0 ,4.0 ,5.0 ,6.0 /) ; a2 = a1call cpu_time(time=c1) !

  • Extensions tableaux Fonctions intrinsques tableaux

    Interrogation (maxloc, lbound, shape, ...)

    SHAPE(source)

    retourne le profil du tableau pass en argument.

    SIZE(array[,dim])

    retourne la taille (ou ltendue de la dimension indique via dim) du tableau pass enargument.

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

    retournent les bornes suprieures/infrieures de chacune des dimensions (ou seulementde celle indique via dim) du tableau pass en argument.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 85 / 317

    Extensions tableaux Fonctions intrinsques tableaux

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

    SHAPE(t) (/ 30,50 /)SIZE(t) 1500SIZE(t,dim=1) 30SIZE(SHAPE(t)) 2 (rang de t)UBOUND(t) (/ 27,49 /)UBOUND(t(:,:)) (/ 30,50 /)UBOUND(t,dim=2) 49LBOUND(t) (/ -2,0 /)LBOUND(t(:,:)) (/ 1,1 /)LBOUND(t,dim=1) -2

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 86 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    MAXLOC(array,dim[,mask]) ou MAXLOC(array[,mask])MINLOC(array,dim[,mask]) ou MINLOC(array[,mask])

    retournent, pour le tableau array de rang n pass en argument, lemplacement dellment maximum/minimum :

    de lensemble du tableau dans un tableau entier de rang 1 et de taille n si dim nestpas spcifi,

    de chacun des vecteurs selon la dimension dim dans un tableau de rang n-1 si dimest spcifi ; si n=1, la fonction retourne un scalaire.

    MASK est un tableau de type logical conformant avec array.DIM=i la fonction travaille globalement sur cet indice (c.--d. un vecteur) pour

    chaque valeur fixe dans les autres dimensions.Ainsi, pour un tableau array de rang 2, la fonction travaille sur :

    les vecteurs array(:,j) c.--d. les colonnes si DIM=1, les vecteurs array(i,:) c.--d. les lignes si DIM=2.

    Exemple

    MAXLOC( (/ 2,-1,10,3,-1 /) ) (/ 3 /)MINLOC( (/ 2,-1,10,3,-1 /),dim=1 ) 2

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 87 / 317

    Extensions tableaux Fonctions intrinsques tableaux

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

    A=

    (0 -5 8 -33 4 -1 21 5 6 -4

    )

    MAXLOC(array=A, mask=A.LT.5) (/ 2,2 /)MINLOC(array=A, mask=A.GT.5) (/ 3,3 /)MINLOC(array=A, mask=A>8 ) [ 0,0 ]MAXLOC(A, dim=2) (/ 3,2,3 /)MAXLOC(A, dim=1) (/ 2,3,1,2 /)MAXLOC(A, dim=2, mask=A

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de rduction

    Selon que DIM est absent ou prsent, toutes ces fonctions retournent soit un scalaire soitun tableau de rang n-1 en dsignant 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) pourchaque valeur fixe dans les autres dimensions.

    A=

    (1 3 52 4 6

    ); B=

    (0 3 57 4 8

    ) A/=B =

    (T F FT F T

    ) Rduction globale : ALL(A.NE.B) .false. Rduction par colonne :ALL(A.NE.B, dim=1) (/ .true.,.false.,.false. /)

    Rduction 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 mme rang) :

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 89 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de rduction

    ANY(mask[,dim])

    A=

    (1 3 52 4 6

    ); B=

    (0 3 57 4 8

    ) A/=B =

    (T F FT F T

    ) Rduction globale : ANY(A/=B) .true. Rduction par colonne :ANY(A/=B, dim=1) (/ .true.,.false.,.true. /)

    Rduction 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 mme rang) :

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 90 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de rduction

    COUNT(mask[,dim])

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

    2 A=

    (1 3 52 4 6

    ); B=

    (0 3 57 4 8

    ) A/=B =

    (T F FT F T

    ) Dcompte global des valeurs vraies :

    COUNT(A/=B) 3 Dcompte par colonne des valeurs vraies :

    COUNT(A/=B,dim=1) (/ 2,0,1 /) Dcompte par ligne des valeurs vraies :

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 91 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de rduction

    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

    2 A=

    (1 3 52 4 6

    )

    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 /)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

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de rduction

    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

    2 A=

    (1 3 52 4 6

    )

    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 /)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 /)SUM(A,dim=2,mask=A

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de multiplication

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

    DOT_PRODUCT(v1,v2)

    v1 de type entier ou rel sum(v1*v2)v1 de type complexe sum(conjg(v1)*v2)v1 et v2 de type logique any(v1.and.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 prcdentes

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 95 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

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

    Cette fonction permet de construire un tableau dun profil donn partir dlments dunautre tableau.

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

    (

    1 3 52 4 6

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

    (/ .true., .true., .true., .true. /) )

    T F F TF T F TF F T TF F F T

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 96 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Notes : PAD : tableau de padding optionnel doit tre array valued ; a ne peut pas tre unscalaire ;

    ORDER : vecteur optionnel contenant lune des n! permutations de (1,2,..,n) o nreprsente le rang du tableau retourn ; il indique lordre de rangement des valeursen sortie. Par dfaut, pour n=2, ce vecteur vaut (/ 1,2 /) ; le remplissage se faitalors classiquement colonne aprs colonne car cest lindice 1 de ligne qui varie leplus vite. linverse, le vecteur (/ 2,1 /) impliquerait un remplissage par lignes ;

    la fonction RESHAPE est utilisable au niveau des initialisations (cf. page 117).

    Exemples

    RESHAPE( source =(/ ((i==j,i=1,4),j=1,3) /), &shape =(/ 4,4 /), &pad =(/ (.true., i=1,4) /), &order =(/ 2,1 /) )

    ( T F F FF T F FF F T FT T T T

    )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 97 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    CSHIFT(array,shift[,dim])

    Fonction permettant deffectuer des dcalages circulaires sur les lments dans unedimension (DIM) donne dun tableau (c.--d. sur des vecteurs). Par dfaut : DIM=1

    Exemples

    integer , dimension (6) :: v = (/ 1,2,3,4,5,6 /)integer , dimension (6) :: w1,w2w1 = CSHIFT( v, shift=2 )w2 = CSHIFT( v, shift=-2 )print *,w1(:)print *,w2(:)

    On obtient w1 = (/ 3,4,5,6,1,2 /)w2 = (/ 5,6,1,2,3,4 /)

    SHIFT > 0 dcalage vers les indices dcroissantsSHIFT < 0 dcalage vers les indices croissants

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 98 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    k

    i

    DIM=1k

    DIM=2

    j j

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

    i

    Note : si array est de rang n et de profil (/ d1, d2, ..., dn /), largument shift doit tre unscalaire ou un tableau dentiers de rang n-1 et de profil(/ d1, d2, ..., ddim1, ddim+1, ..., dn /).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 99 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Soit M le tableau

    a b c de f g hi j k lm n o p

    CSHIFT( array=M, shift=-1 )

    m n o pa b c de f g hi j k l

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

    c d a bg h e fl i j km n o p

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 100 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Drive dune matrice via CSHIFT

    Soit calculer la drive D(M,N) suivant la 2e dimension dune matrice F(M,N) dfinie surun domaine suppos cylindrique :

    via une double boucle classique :do i=1,M

    do j=1,ND(i,j) = 0.5 * ( F(i,j+1) - F(i,j-1) )

    end doend do

    Mais il faudrait rajouter le traitement priodique des donnes aux frontires dudomaine cylindrique, c.--d. remplacer F(:,N+1) par F(:,1) et F(:,0) par F(:,N)

    avec la fonction CSHIFT :D(:,:) = 0.5*( CSHIFT(F,1,2) - CSHIFT(F,-1,2) )

    La fonction CSHIFT traite automatiquement le problme des frontires.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 101 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

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

    Cette fonction permet deffectuer des dcalages sur les lments dun tableau dans unedimension (DIM) donne avec possibilit de remplacer ceux perdus (End Off) la"frontire" (boundary) par des lments de remplissage.SHIFT > 0 dcalage vers les indices dcroissantsSHIFT < 0 dcalage vers les indices croissants

    Par dfaut : DIM=1Si, lors dun remplacement, aucun lment de remplissage (boundary) nest disponiblecelui par dfaut est utilis. Il est fonction du type des lments du tableau trait.

    Type du tableau Valeur par dfautINTEGER 0REAL 0.0COMPLEX (0.0,0.0)LOGICAL .false.CHARACTER(len) len blancs

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 102 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Exemples

    integer , dimension (6) :: v = (/ (i,i=1,6) /)integer , dimension (6) :: w1, w2w1 = EOSHIFT( v, shift =3 )w2 = EOSHIFT( v, shift=-2, boundary =100 )

    On obtient : w1 = (/ 4,5,6,0,0,0 /)w2 = (/ 100,100,1,2,3,4 /)

    character , dimension (4,4) :: t1_car , t2_car

    t1_car=RESHAPE( source = (/ (achar(i),i=97 ,112) /), &shape = shape(t1_car) )

    t2_car=EOSHIFT( array = t1_car , &shift = 3, &boundary = (/ (achar(i),i=113 ,116) /) )

    t1_car =

    a e i mb f j nc g k od h l p

    ; t2_car = d h l pq r s tq r s t

    q r s t

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 103 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    PACK(array,mask[,vector])

    Fonction permettant de compresser un tableau sous le contrle dun masque. Le rsultatest un vecteur.

    PACK

    UNPACK

    x y z

    X Y Z

    X

    Z

    Y

    MASK FIELDMASK

    PACK(ARRAY, MASK [, VECTOR] )

    UNPACK(VECTOR, MASK, FIELD)

    xz

    y

    VECTOR

    Traitement

    Exemples

    integer , dimension (3,3) :: a=0a = EOSHIFT(a, shift =(/ 0,-1,1 /), boundary =(/ 1, 9,6 /))print *, PACK(a, mask=a/=0)print *, PACK(a, mask=a/=0, vector =(/ (i**3,i=1,5) /))

    (/ 9,6 /) ; (/ 9,6,27,64,125 /)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 104 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Notes : pour linariser une matrice : PACK( a, mask=.true. ) ; dfaut de largument VECTOR, le rsultat est un vecteur de taille gale au nombredlments vrais du masque (COUNT(MASK)).Si VECTOR est prsent, le vecteur rsultat aura la mme taille que lui (et seracomplt en "piochant" dans VECTOR), ce qui peut tre utile pour assurer laconformance dune affectation. Le nombre dlments de VECTOR doit tre gal ousuprieur au nombre dlments vrais du masque.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 105 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    UNPACK(vector,mask,field)

    Fonction dcompressant un vecteur sous le contrle dun masque.Pour tous les lments vrais du masque, elle pioche les lments de VECTOR et pour tousles lments faux du masque, elle pioche les lments correspondants de FIELD qui jouele rle de trame de fond . MASK et FIELD doivent tre conformants ; leur profil est celuidu tableau retourn.Exemples

    integer , dimension (3) :: v2 = 1integer , dimension (3) :: v = (/ 1,2,3 /)integer , dimension (3,3) :: a, fldlogical , dimension (3,3) :: mm = RESHAPE( source =(/ ((i==j,i=1,3),j=1,3) /),&

    shape = shape(m) )fld = UNPACK( v2 , mask=m, field=0 )m = CSHIFT( m, shift =(/ -1,1,0 /), dim=2 )a = UNPACK( v, mask=m, field=fld )

    m

    (T F FF T FF F T

    )fld

    (1 0 00 1 00 0 1

    )m

    (F T FT F FF F T

    )a

    (1 2 01 1 00 0 3

    )Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 106 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    Compression/dcompression dune matrice tridiagonale

    integer ,parameter :: n=5real , dimension(n,n) :: Alogical , dimension(n,n) :: mreal ,dimension(n + 2*(n-1)) :: v!--Valorisation de la matrice A. . . . . . .!--Cration dun masque tridiagonalm=reshape( (/ ((i==j.or.i==j-1.or.i==j+1,i=1,n),j=1,n) /), &

    shape=shape(m) )!--Compression (lments tri -diagonaux)v=pack( A,mask=m )!--Traitement des lments tri -diagonaux!--compresssv=v+1. ; . . . . .!--Dcompression aprs traitementA=unpack( v,mask=m,field=A )!--Impressiondo i=1,size(A,1)

    print "(10(1x,f7.5))", A(i,:)end do

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 107 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    SPREAD(source,dim,ncopies)

    Duplication par ajout dune dimension. Si n est le rang du tableau dupliquer, le rang dutableau rsultat sera n+1.

    Exemples

    1 duplication selon les colonnes par un facteur 3integer , dimension (3) :: a = (/ 4,8,2 /)print *, SPREAD(source=a, dim=2, ncopies =3)

    (4 4 48 8 82 2 2

    )2 dilatation/expansion dun vecteur par un facteur 4

    integer , dimension (3) :: a = (/ 4,8,2 /)print *, PACK( array=SPREAD(source=a, dim=1, ncopies =4), &

    mask=.true. )

    (/ 4 4 4 4 8 8 8 8 2 2 2 2 /)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 108 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Fonctions de construction/transformation

    TRANSPOSE(matrix)

    Cette fonction permet de transposer la matrice passe en argument.

    Exemple

    integer , dimension (3,3) :: a, b, ca = RESHAPE( source = (/ (i**2,i=1,9) /), &

    shape = shape(a) )b = TRANSPOSE( matrix=a )c = RESHAPE( source = a, &

    shape = shape(c), &order = (/ 2,1 /) )

    a =

    (1 16 494 25 649 36 81

    )b =

    (1 4 9

    16 25 3649 64 81

    )c =

    (1 4 9

    16 25 3649 64 81

    )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 109 / 317

    Extensions tableaux Fonctions intrinsques tableaux

    La fonction suivante est une fonction lmentaire, cest--dire que celle-ci a t dfiniepour traiter des scalaires et stend automatiquement des arguments de type tableau.

    MERGE(tsource,fsource,mask)

    Exemple 1 : fusion de deux tableaux sous le contrle dun masque

    a =

    (1 2 34 5 67 8 9

    ); b =

    (-1 -2 -3-4 -5 -6-7 -8 -9

    ); m =

    (T F FF T FF F T

    )

    MERGE(tsource=a, fsource=b, mask=m)

    (1 -2 -3

    -4 5 -6-7 -8 9

    )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 110 / 317

  • Extensions tableaux Fonctions intrinsques tableaux

    Exemple 2 : en remplacement dun test

    use ISO_FORTRAN_ENVreal x, y, zlogical flag

    x = acos (-1.)z = exp (1.)read(INPUT_UNIT , *) flag

    if (flag) theny = x

    elsey = z

    end if

    ! autre criture

    y = MERGE(tsource=x, fsource=z, mask=flag)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 111 / 317

    Extensions tableaux Instruction et bloc WHERE

    Instruction et bloc WHERE

    Linstruction WHERE permet deffectuer des affectations de type tableau par lintermdiaire dunfiltre (masque logique) :

    [tiq:] WHERE (mask)bloc1

    ELSEWHERE [tiq]bloc2

    END WHERE [tiq]

    O mask est une expression logique retournant un tableau de logiques.Remarque : bloc1 et bloc2 sont constitus uniquement dinstructions daffectation portant surdes tableaux conformants avec le masque.

    Exemple

    real , dimension (10) :: a...

    WHERE (a > 0.)a = log(a)

    ELSEWHEREa = 1.

    END WHERE

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 112 / 317

  • Extensions tableaux Instruction et bloc WHERE

    Instruction et bloc WHERE

    Ce qui est quivalent :

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

    a(i) = log(a(i))else

    a(i) = 1.end if

    end do

    Remarques

    Lorsque bloc2 est absent et que bloc1 se rsume une seule instruction, on peututiliser la forme simplifie : WHERE (expression_logique_tableau) instruction

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

    Dans lexemple suivant : WHERE(a>0.) a = a - sum(a) , la fonction sum estvalue comme la somme de tous les lments de a, car sum nest pas une fonctionlmentaire (fonction que lon peut appliquer sparment tous les lments duntableau).Cependant laffectation nest effectue que pour les lments positifs de a.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 113 / 317

    Extensions tableaux Instruction et bloc WHERE

    Instruction et bloc WHERE

    Considrons lexemple suivant :

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

    La rgle veut que les fonctions lmentaires (ici sqrt) apparaissant en argumentdune fonction non lmentaire (ici sum) ne soient pas soumises au masque.Lexpression sum(sqrt(a)) sera donc calcule sur tous les lments de a. Celaprovoquera bien sr une erreur si lune au moins des valeurs de a est ngative.

    Lors de lexcution dune instruction ou dun bloc WHERE le masque est valu avantque les instructions daffectation ne soient excutes. Donc si celles-ci modifient lavaleur du masque, cela naura aucune incidence sur le droulement de linstructionou du bloc WHERE.

    On ne peut imbriquer des blocs WHERE.

    Norme 95 : il est possible dimbriquer des blocs WHERE qui peuvent tre tiquets de lamme faon que le bloc select ou la boucle DO par exemple. De plus, le bloc WHERE peutcontenir plusieurs clauses ELSEWHERE avec masque logique (sauf le dernier).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 114 / 317

  • Extensions tableaux Expressions dinitialisation

    Expressions dinitialisation

    Une expression dinitialisation ( initialization-expression ) doit tre forme laide deconstantes ou dexpressions constantes. Ce type dexpression est utilis lors dunedclaration et peut tre construite laide dlments comme indiqus dans les exemplessuivant :

    constructeur de vecteur (avec boucles implicites) :integer iinteger , dimension (10) :: t1=(/ (i*2, i=1 ,10) /)

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

    fonctions intrinsques lmentaires :integer , parameter :: n=12**4integer(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 ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 115 / 317

    Extensions tableaux Expressions dinitialisation

    fonctions intrinsques dinterrogation (LBOUND, UBOUND, SHAPE, SIZE, BIT_SIZE,KIND, LEN, DIGITS, EPSILON, HUGE, TINY, RANGE, RADIX, MAXEXPONENT,MINEXPONENT) :real , dimension (10 ,20) :: ainteger :: d=size(a ,1)*4integer :: n=kind (0.D0)

    fonctions de transformation (REPEAT, RESHAPE, TRIM, SELECTED_INT_KIND,SELECTED_REAL_KIND, TRANSFER, NULL, . . .) :integer iinteger , dimension (4,2) :: t = &

    reshape( source =[ (i,i=1,8) ], shape=shape(t) )

    real , pointer :: p=>null()

    Remarque La notation [] utilise dans lexemple prcdent a t introduite par la norme

    2003 pour lcriture du constructeur de vecteur. Il est bien entendu que lescaractres habituels (/, /) sont toujours valides.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 116 / 317

  • Extensions tableaux Exemples dexpressions tableaux

    Exemples dexpressions tableaux

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

    ai SUM(A)i

    ai cos xi SUM(A*cos(X))|ai | 0.)

    M1 = maxji

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

    M = maxij

    |mij | 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 ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 118 / 317

  • Gestion mmoire

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoireExpressions de spcificationTableaux automatiquesTableaux dynamiques ALLOCATABLE, profil diffrArgument muet ALLOCATABLE : norme 2003Composante allouable dun type driv : norme 2003Allocation dun scalaire ALLOCATABLE : norme 2003Allocation/rallocation via laffectation : norme 2003Procdure MOVE_ALLOC de rallocation : norme 2003

    7 Pointeurs

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 119 / 317

    Gestion mmoire

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 120 / 317

  • Gestion mmoire Expressions de spcification

    Expressions de spcification

    Une expression de spcification ( specification-expression ) est une expression formeau moyen de constantes et de variables dont les valeurs peuvent tre dtermines lentre dune procdure avant toute excution dinstructions excutables. Cest uneexpression scalaire entire.Ces variables peuvent tre des arguments muets, dfinies dans un COMMON ou bienaccessibles via use ou host-association .Des fonctions intrinsques telles que LBOUND, UBOUND, SHAPE, SIZE, BIT_SIZE, KIND,LEN, DIGITS, EPSILON, HUGE, TINY, RANGE, RADIX, MAXEXPONENT, MINEXPONENT peuventapparatre au sein de ces expressions.Ce type dexpression est employ pour prciser les dimensions de tableaux et leslongueurs de chanes de caractres comme dans lexemple suivant :

    Exemple

    subroutine sp( n, m, c, ... )! Dclarations des argumentsinteger n, mcharacter(len =*) c! Dclarations des variables localesreal , dimension(n*m) :: veccharacter(len=len(c)) :: chaine

    ...end subroutine sp

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 121 / 317

    Gestion mmoire Tableaux automatiques

    Il est possible de dfinir au sein dune procdure des tableaux dont la taille varie dunappel lautre. Ils sont allous dynamiquement lentre de la procdure et librs sasortie de faon implicite.Pour cela ces tableaux seront dimensionns laide dexpressions de spcificationrenfermant des variables.Ces tableaux sont appels tableaux automatiques ; cest le cas des tableaux C et V delexemple suivant :Exemple

    subroutine echange(a, b, taille)integer , dimension (:,:) :: a, binteger :: tailleinteger , dimension(size(a,1),size(a,2)) :: Creal , dimension(taille) :: VC = aa = bb = C

    ...end subroutine echange

    Remarques pour pouvoir excuter ce sous-programme, linterface doit tre explicite (cf. chapitre 8),

    un tableau automatique ne peut tre initialis.Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 122 / 317

  • Gestion mmoire Tableaux dynamiques ALLOCATABLE, profil diffr

    Tableaux dynamiques ALLOCATABLE, profil diffr

    Un apport intressant de la norme Fortran 90 est la possibilit de faire de lallocationdynamique de mmoire. Pour pouvoir allouer un tableau dynamiquement on spcifieralattribut ALLOCATABLE au moment de sa dclaration. Un tel tableau sappelle tableau profil diffr (deffered-shape-array).Son allocation seffectuera grce linstruction ALLOCATE laquelle on indiquera le profildsir. Linstruction DEALLOCATE permet de librer lespace mmoire allou. De plus lafonction intrinsque ALLOCATED permet dinterroger le systme pour savoir si un tableauest allou ou non.Exemple

    real , dimension (:,:), ALLOCATABLE :: ainteger :: n,m,etatread *, n, mif (.not. ALLOCATED(a)) then

    ALLOCATE(a(n,m),stat=etat)if (etat /= 0) then

    print *,"Erreur allocat. tableau a" ; stop 4end if

    end if...

    DEALLOCATE(a)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 123 / 317

    Gestion mmoire Tableaux dynamiques ALLOCATABLE, profil diffr

    Tableaux dynamiques ALLOCATABLE, profil diffr : remarques

    attention : en cas de problme au moment de lallocation et en labsence duparamtre STAT=etat, lexcution du programme sarrte automatiquement avec unmessage derreur (traceback) ; sil est prsent, lexcution continue en squence etcest vous de tester la valeur retourne dans la variable entire etat qui estdiffrente de zro en cas de problme ;

    il nest pas possible de rallouer un tableau dj allou. Il devra tre librauparavant ;

    un tableau local allou dynamiquement dans une unit de programme a un tatindtermin la sortie (RETURN/END) de cette unit sauf dans les cas suivants :

    lattribut SAVE a t spcifi pour ce tableau ; une autre unit de progr. encore active a visibilit par use association sur ce tableau

    dclar dans un module ; cette unit de progr. est interne. De ce fait (host association), lunit hte peut encore

    y accder.Norme 95 : ceux restant ltat indtermin sont alors automatiquement librs ;

    un tableau dynamique peut avoir lattribut TARGET ; sa libration (deallocate) doitobligatoirement se faire en spcifiant ce tableau et en aucun cas un pointeurintermdiaire lui tant associ ;

    un tableau dynamique peut tre transmis en argument. Selon les normes 90/95largument muet correspondant ne doit pas avoir lattribut ALLOCATABLE : il devratre allou avant lappel et cest un tableau classique qui sera alors rcupr dans laprocdure appele.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 124 / 317

  • Gestion mmoire Argument muet ALLOCATABLE : norme 2003

    Argument muet ALLOCATABLE : norme 2003

    depuis la Norme 2003, il est possible de prciser lattribut allocatable pour leretour dune fonction ainsi que pour un argument muet dune procdure : linterfacedevra tre explicite ;

    si largument muet a lattribut allocatable, largument dappel correspondant nepeut pas tre prcis sous forme dune section de tableau et doit aussi avoir cetattribut ainsi que le mme rang et le mme type/sous-type, sans tre ncessairementdj allou : sil lest, il sera alors possible de rcuprer ses bornes au sein de laprocdure appele (voir exemple ci-aprs).

    Exemple

    program allocaimplicit nonereal , dimension (:), ALLOCATABLE :: vec_x , vec_y

    allocate( vec_y ( -2:100) )call sp( vec_x , vec_y )print *, vec_x( (/ lbound(vec_x), ubound(vec_x) /) ), vec_y( (/ -2, 100 /) )deallocate( vec_x ); deallocate( vec_y )

    CONTAINSsubroutine sp( v_x , v_y )

    real , dimension (:), ALLOCATABLE , intent(inout) :: v_x , v_yALLOCATE(v_x (256))call random_number(v_x); call random_number(v_y)print *, "Bornes inf/sup(v_y) : ", lbound( v_y ), ubound( v_y )

    end subroutine spend program alloca

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 125 / 317

    Gestion mmoire Composante allouable dun type driv : norme 2003

    Composante allouable dun type driv : norme 2003

    Dsormais la norme 2003 autorise lemploi de lattribut ALLOCATABLE au niveau dunecomposante dun type driv. Les normes prcedentes (90/95) nautorisaient quelattribut POINTER pour grer des composantes dynamiques.

    Exemple

    program allocatype obj_mat

    integer :: N, Mreal , dimension (:,:), ALLOCATABLE :: A

    end type obj_mattype(obj_mat) :: mat

    read *, mat%N, mat%Mallocate( mat%A(mat%N, mat%M) ); call random_number( mat%A )print *, mat%A( (/ 1, mat%N /), (/ 1, mat%M /) )deallocate( mat%A )

    end program alloca

    Remarques la composante A de mat est en vrit un descripteur opaque renfermant les caractristiques

    du tableau allouable (adresse du tableau, profil, bornes inf/sup, ...) ; lorsque lemplacement en mmoire dun objet de type driv est libr (explicitement via

    une instruction deallocate ou bien implicitement par le compilateur), si celui-ci admet descomposantes avec lattribut ALLOCATABLE, celles-ci seront automatiquement dsalloues(voir exemple transparent suivant).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 126 / 317

  • Gestion mmoire Composante allouable dun type driv : norme 2003

    Libration automatique de zones dynamiques

    Exempleprogram zones_dyn

    implicit nonetype vecteur

    real x, y, zend type vecteurtype champs_vecteurs

    integer ntype(vecteur), dimension (:), allocatable :: champs

    end type champs_vecteurstype(champs_vecteurs), dimension (:), allocatable :: tab_champsinteger nb_elts , i

    read *,nb_eltsallocate(tab_champs(nb_elts ))do i=1,nb_elts

    read *,tab_champs(i)%nallocate(tab_champs(i)% champs(tab_champs(i)%n))

    ...end do

    ...deallocate(tab_champs) ! Dsallocation automatique des composantes champs

    ...

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 127 / 317

    Gestion mmoire Allocation dun scalaire ALLOCATABLE : norme 2003

    Allocation dun scalaire ALLOCATABLE : norme 2003

    Lattribut ALLOCATABLE peut dornavant sappliquer un scalaire, notamment unechane de caractres.

    Exemple

    program alloca_charimplicit nonecharacter(len =256) :: ch_incharacter(len=:), ALLOCATABLE :: ch_outread( *, "(A)" ) ch_in; ch_out = 1 strdup( ch_in )print "(i0 ,1x,a)", len(ch_out), ch_outdeallocate( ch_out )

    containsfunction strdup( ch_in )

    character(len=*) :: ch_incharacter(len=:), ALLOCATABLE :: strdupallocate( character(len=len_trim(ch_in)) :: strdup ) ! Facultatif ici 1

    strdup = trim( ch_in )end function strdup

    end program alloca_char

    Dans cet exemple, la fonction strdup retourne une chane de caractres allouable dont lalongueur est celle de la chane passe en argument dbarrasse des blancs de fin. Lallocation esteffectue laide de linstruction ALLOCATE en explicitant le type et la longueur dsire.

    1. dans le cas o lallocation nest pas prcise, elle sera effectue automatiquement lors de laffectation (voirtransparent suivant)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 128 / 317

  • Gestion mmoire Allocation/rallocation via laffectation : norme 2003

    Allocation/rallocation via laffectation : norme 2003

    Une allocation/rallocation dune entit ayant lattribut ALLOCATABLE peut se faireimplicitement lors dune opration daffectation du type :

    var_alloc = expression

    1 si var_alloc est dj alloue, elle est automatiquement dsalloue si des diffrences(concernant le profil par exemple) existent entre var_alloc et expression ;

    2 si var_alloc est ou devient dsalloue, alors elle est ralloue selon lescaractristiques de expression.

    Voici un exemple permettant le traitement dune chane de caractres de longueurvariable :

    character (:), ALLOCATABLE :: NAME. . . .

    NAME = "Beethoven"; ...; NAME = "Ludwig -Van Beethoven"

    La variable scalaire NAME de type CHARACTER sera alloue lors de la premire affectationavec une longueur LEN=9. Lors de la 2e affectation, elle sera dsalloue puis ralloueavec une longueur LEN=20.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 129 / 317

    Gestion mmoire Allocation/rallocation via laffectation : norme 2003

    noter que cette possibilit de rallocation dynamique facilite la gestion des chanesdynamiques ainsi que le respect de la contrainte de conformance lors dune affectation detableaux. Ainsi par exemple :real , ALLOCATABLE , dimension (:) :: x

    ...!--allocate( x(count( masque )) )

  • Gestion mmoire Procdure MOVE_ALLOC de rallocation : norme 2003

    Procdure MOVE_ALLOC de rallocation : norme 2003

    MOVE_ALLOC(FROM, TO)

    Ce sous-programme permet de transfrer une allocation dun objet allouable un autredans le but , par exemple, dtendre un objet dj allou.

    FROM fait rfrence une entit allouable de nimporte quel type/rang ; TO fait rfrence une entit allouable de type compatible avec FROM et de mmerang ;

    En retour de ce sous-programme, le tableau allouable TO dsigne le tableau allouableFROM ; la zone mmoire pralablement dsigne par TO est dsalloue.En fait, cest un moyen permettant de vider le descripteur de FROM aprs lavoir recopidans celui de TO.

    si FROM nest pas allou en entre, TO devient non allou en sortie ; sinon, TO devient allou avec les mmes caractristiques (type dynamique,paramtres de type, bornes de tableau, valeurs) que FROM avait en entre ;

    si TO a lattribut TARGET, tout pointeur initialement associ FROM devient associ TO.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 131 / 317

    Gestion mmoire Procdure MOVE_ALLOC de rallocation : norme 2003

    Exemple

    real , ALLOCATABLE , dimension (:) :: grid , tempgrid...

    ALLOCATE(grid(-N:N)) ! Allocation initiale de grid...

    ALLOCATE(tempgrid (-2*N:2*N)) ! Allocation dune grille plus grande... !

    tempgrid (::2) = grid ! Redistribution des valeurs de grid... !

    call MOVE_ALLOC( TO=grid , FROM=tempgrid )

    tempgrid

    x2N +2N

    3

    grid

    xN +N

    1

    4

    TO

    FROM

    2

    Figure 1 : Schma correspond au move_alloc prcdent

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 132 / 317

  • Gestion mmoire Procdure MOVE_ALLOC de rallocation : norme 2003

    Exemple prcdent en Fortran 90/95

    real , ALLOCATABLE , dimension (:) :: grid , tempgrid... !

    ALLOCATE(grid(-N:N)) ! Allocation initiale de grid... !

    ALLOCATE(tempgrid (-2*N:2*N)) ! Allocation dune grille plus grande... !

    tempgrid (::2) = grid ! Redistribution des valeurs de grid... !

    DEALLOCATE( grid (:) )ALLOCATE( grid(-2*N:2*N) )grid (:) = tempgrid (:)DEALLOCATE( tempgrid (:) )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 133 / 317

    Pointeurs

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 PointeursDfinition, tats dun pointeurDclaration dun pointeurSymbole =>Symbole = appliqu aux pointeursAllocation dynamique de mmoireImbrication de zones dynamiquesFonction NULL() et instruction NULLIFYFonction intrinsque ASSOCIATEDSituations viterDclaration de tableaux de pointeurs

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 134 / 317

  • Pointeurs

    Passage dun pointeur en argument de procdurePassage dune cible en argument de procdurePointeur, tableau profil diffr et COMMONListe chane

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 135 / 317

    Pointeurs Dfinition, tats dun pointeur

    Dfinition, tats dun pointeur

    En C, Pascal variable contenant ladresse dobjetsEn Fortran 90 alias dobjets

    Tout pointeur Fortran a un tat parmi les suivants :

    1 Indfini : sa dclaration en tte de programme ;2 Nul : alias daucun objet ;3 Associ : alias dun objet (cible).

    Note : pour ceux connaissant la notion de pointeur (type langage C), disons que lepointeur Fortran 90 est une abstraction de niveau suprieur en ce sens quil interdit lamanipulation directe dadresse. chaque pointeur Fortran 90 est associ un descripteur interne contenant les caractristiques (type, rang, tat, adresse de la cible,et mme le pas dadressage en cas de section rgulire, etc . . . ). Pour toute rfrence ce pointeur, lindirection est faite pour vous, do la notion d alias . Comme nousallons le voir, ce niveau dabstraction suprieur ne limite en rien (bien au contraire) lesapplications possibles.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 136 / 317

  • Pointeurs Dclaration dun pointeur

    Dclaration dun pointeur

    Attribut pointer spcifi lors de sa dclaration.

    Exemple

    real , pointer :: p1integer , dimension (:), pointer :: p2character(len=80), dimension (:,:), pointer :: p3character(len=80), pointer :: p4(:)------------------------------------------type boite

    integer icharacter(len =5) t

    end typetype(boite), pointer :: p5------------------------------------------

    Attention : p4 nest pas un tableaux de pointeurs ! !Note : p4 est en fait un pointeur susceptible dtre ultrieurement associ un tableaude rang 1 et de type chanes de caractres . Bien quautorise, la dclaration ci-dessusest ambigu ; on lui prfrera donc systmatiquement la forme classique :

    character(len=80), dimension (:), pointer :: p4

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 137 / 317

    Pointeurs Symbole =>

    Symbole =>

    Cible : cest un objet point. Cet objet devra avoir lattribut target lors de sadclaration :

    integer , target :: i

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

    Pointeur Cible

    op1

    op2

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 138 / 317

  • Pointeurs Symbole =>

    Exemple

    integer , target :: ninteger , pointer :: ptr1 , ptr2

    n = 10ptr1 => nptr2 => ptr1n = 20print *, ptr2

    Remarque p1 et p2 tant deux pointeurs, p2 => p1 implique que p2 prend ltat de p1(indfini, nul ou associ la mme cible).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 139 / 317

    Pointeurs Symbole =>

    Un pointeur peut tre un alias dobjets plus complexes :Exemple

    implicit nonereal , dimension (10,20), target :: areal , dimension (:), pointer :: pinteger :: i

    !a = reshape(source =(/ (i, i=1 ,200) /), shape=[ 10,20 ])! Lappel suivant est prfrable :a = reshape(source =(/ (i, i=1 ,200) /), shape=shape(a))read(*, *) ip => a(i, 1:10:3) ! p est maintenant un vecteur de profil (/ 4 /)print *, p(3)end

    20101

    1

    i

    10

    p(3)

    a(10,20)Matrice

    p => a(i, 1:10:3)

    4 7

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 140 / 317

  • Pointeurs Symbole = appliqu aux pointeurs

    Symbole = appliqu aux pointeurs

    Attention : lorsque les oprandes du symbole = sont des pointeurs, laffectation seffectue sur lescibles et non sur les pointeurs.

    Exemple

    implicit noneinteger :: iinteger , pointer :: ptr1 , ptr2integer , target :: i1 , i2real , dimension (3,3), target :: a, breal , dimension (:,:), pointer :: p, q!-----------------------------------------i1 = 1 ; i2 = 2ptr1 => i1; ptr2 => i2ptr2 = ptr1 ! quivalent "i2 = i1"print *, i2!-----------------------------------------a = reshape(source =(/ (i, i=1,9) /), shape=shape(a))p => a; q => bq = p + 1. ! ou q = a + 1.print *, bend

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 141 / 317

    Pointeurs Allocation dynamique de mmoire

    Allocation dynamique de mmoire

    Linstruction ALLOCATE permet dassocier un pointeur et dallouer dynamiquement de la mmoire.

    Exemple

    implicit noneinteger , dimension (:,:), pointer :: pinteger :: nread(*, *) nALLOCATE(p(n, n))p = reshape(source =(/ (i, i=1,n*n) /), shape=shape(p))print *,pDEALLOCATE(p)end

    Remarques

    Lespace allou na pas de nom, on y accde par lintermdiaire du pointeur. Pour librer la place alloue on utilise linstruction DEALLOCATE Aprs lexcution de linstruction DEALLOCATE le pointeur passe ltat nul. Linstruction DEALLOCATE applique un pointeur dont ltat est indtermin provoque une

    erreur. Possibilit dallocation dynamique dun scalaire ou dune structure de donnes via un

    pointeur : application aux listes chanes (cf. page 55 et 159).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 142 / 317

  • Pointeurs Imbrication de zones dynamiques

    Imbrication de zones dynamiques

    Dans le cas de zones dynamiques imbriques, on prendra garde librer ces zonesconvenablement. Il suffira dappliquer la rgle suivante :

    Les zones seront libres dans lordre inverse de celui qui a servi les allouer.

    Exemple

    program zones_dynimplicit nonetype vecteur

    real x, y, zend type vecteurtype champs_vecteurs

    integer ntype(vecteur), dimension (:), pointer :: champs

    end type champs_vecteurstype(champs_vecteurs), dimension (:), allocatable :: tab_champsinteger nb_elts , i

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 143 / 317

    Pointeurs Imbrication de zones dynamiques

    Exemple (suite)

    read *,nb_eltsallocate(tab_champs(nb_elts ))do i=1,nb_elts

    read *,tab_champs(i)%nallocate(tab_champs(i)% champs(tab_champs(i)%n))

    ...end do

    ...do i=1,nb_elts

    deallocate(tab_champs(i)% champs)end dodeallocate(tab_champs)

    ...end program zones_dyn

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 144 / 317

  • Pointeurs Fonction NULL() et instruction NULLIFY

    Fonction NULL() et instruction NULLIFY

    Au dbut dun programme un pointeur nest pas dfini : son tat est indtermin.La fonction intrinsque NULL() (Norme 95) permet de forcer un pointeur ltat nul (y comprislors de sa dclaration).

    Exemple

    real , pointer , dimension (:) :: p1 => NULL()...

    p1 => NULL()...

    Linstruction NULLIFY permet de forcer un pointeur ltat nul :

    real , pointer :: p1, p2

    nullify(p1)nullify(p2)

    ...

    Remarques Si deux pointeurs p1 et p2 sont alias de la mme cible, NULLIFY(p1) force le pointeur p1

    ltat nul, par contre le pointeur p2 reste alias de sa cible. Si p1 est ltat nul, linstruction p2 => p1 force p2 ltat nul.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 145 / 317

    Pointeurs Fonction intrinsque ASSOCIATED

    Fonction intrinsque ASSOCIATED

    Il nest pas possible de comparer des pointeurs, cest la fonction intrinsque ASSOCIATEDqui remplit ce rle :

    ASSOCIATED(pointer[, target])

    ASSOCIATED(p) vrai si p est associ une cible faux si p est ltat nul

    ASSOCIATED(p1, p2) vrai si p1 et p2 sont alias de la mme cible faux sinon

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

    Remarques largument optionnel TARGET peut tre au choix une cible ou un pointeur ; le pointeur ne doit pas tre dans ltat indtermin ; si p1 et p2 sont ltat nul alors ASSOCIATED(p1,p2) renvoie faux.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 146 / 317

  • Pointeurs Situations viter

    Situations viter

    Exemple 1

    implicit nonereal , dimension (:,:), pointer :: p1 , p2integer :: n

    read(*, *) nallocate(p2(n, n))p1 => p2deallocate(p2)

    ...

    Ds lors lutilisation de p1 peut provoquer des rsultats imprvisibles.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 147 / 317

    Pointeurs Situations viter

    Exemple 2

    implicit nonereal , dimension (:,:), pointer :: pinteger :: n

    read(*, *) nallocate(p(n, 2*n))p = 1.p => NULL()

    ...

    La zone anonyme alloue en mmoire grce linstruction ALLOCATE nest plusrfrenable !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 148 / 317

  • Pointeurs Situations viter

    Exemple 3 : erron

    implicit nonereal , dimension (:,:), &

    allocatable , &target :: mat

    real , dimension (:,:), &pointer :: p => NULL()

    p => mat...

    allocate(mat (10 ,20))p = ...

    ...

    Exemple 3 : correct

    implicit nonereal , dimension (:,:), &

    allocatable , &target :: mat

    real , dimension (:,:), &pointer :: p => NULL()

    allocate(mat (10 ,20))p => matp = ...

    ...

    Remarques un tableau ayant lattribut ALLOCATABLE peut tre la cible dun pointeur ; avant deffectuer lassociation, il faut bien prendre garde ce que le tableau soitallou.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 149 / 317

    Pointeurs Dclaration de tableaux de pointeurs

    Dclaration de tableaux de pointeurs

    Exemple dutilisation dun tableau de pointeurs pour trier (sur la sous-chane correspondantaux caractres 5 9) un tableau de chanes de caractres de longueur 256 :

    Tri avec tableaux de pointeurs

    module chainetype ptr_chaine

    character(len =256), pointer :: p => null()end type ptr_chaine

    end module chaine

    program tri_chaineuse chaineimplicit nonetype(ptr_chaine), &

    dimension (:), allocatable :: tab_pointeurscharacter(len =256), target , &

    dimension (:), allocatable :: chainesinteger :: nbre_chaineslogical :: tri_termineinteger :: i, eofprint *,"Entrez le nombre de chanes :"read(*, *) nbre_chainesallocate(tab_pointeurs(nbre_chaines),chaines(nbre_chaines ))

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 150 / 317

  • Pointeurs Dclaration de tableaux de pointeurs

    Tri avec tableaux de pointeurs (suite)

    do i=1, nbre_chainesprint *,"Entrez une chane : "; read (*,*) chaines(i)tab_pointeurs(i)%p => chaines(i)

    end dodo

    tri_termine = .true.do i=1, nbre_chaines - 1

    if (tab_pointeurs(i )%p(5:9) > tab_pointeurs(i+1)%p(5:9)) then!----- Permutation des deux associations -----tab_pointeurs(i:i+1) = tab_pointeurs(i+1:i:-1)!---------------------------------------------tri_termine = .false.

    end ifend doif (tri_termine) exit

    end doprint "(/, a)","Liste des chanes tries :"print "(a)", (tab_pointeurs(i)%p, i=1,size(tab_pointeurs ))deallocate(chaines , tab_pointeurs)

    end program tri_chaine

    Note : laffectation entre structures implique lassociation des composantes de typepointeur, do lcriture trs simplifie de la permutation sous forme dune simpleaffectation.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 151 / 317

    Pointeurs Passage dun pointeur en argument de procdure

    Passage dun pointeur en argument de procdure

    1 Largument muet na pas lattribut pointer : le pointeur doit tre associ avant lappel, cest ladresse de la cible associe qui est passe, linterface peut tre implicite ce qui permet lappel dune procdure Fortran 77.Attention : dans ce cas si la cible est une section rgulire non contigu, lecompilateur transmet une copie contigu, do un impact possible sur les performances(cf. chap. 5 page 83).

    2 Largument muet a lattribut pointer : le pointeur nest pas ncessairement associ avant lappel (avantage par rapport

    allocatable), cest ladresse du descripteur du pointeur qui est passe, linterface doit tre explicite (pour que le compilateur sache que largument muet a

    lattribut pointer), si le pointeur pass est associ un tableau avant lappel, les bornes

    infrieures/suprieures de chacune de ses dimensions sont transmises la procdure ;elles peuvent alors tre rcupres via les fonctions UBOUND/LBOUND.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 152 / 317

  • Pointeurs Passage dune cible en argument de procdure

    Passage dune cible en argument de procdure

    Lattribut target peut tre spcifi soit au niveau de largument dappel, soit au niveau delargument muet, soit au niveau des deux. Si largument muet a lattribut target, linterface doittre explicite :

    1 si largument muet avec lattribut target est un scalaire ou un tableau profil implicitesans lattribut contiguous et largument dappel a galement lattribut target diffrentdune section irrgulire alors :

    tout pointeur associ largument dappel devient associ largument muet ; au retour de la procdure, tout pointeur associ largument muet reste associ

    largument dappel.2 si largument muet avec lattribut target est un tableau profil explicite, un tableau

    profil implicite avec lattribut contiguous ou un tableau taille implicite et que largumentdappel a galement lattribut target diffrent dune section irrgulire et rfrenant deslments non contigus alors 1 :

    le fait que tout pointeur associ largument dappel devienne associ largumentmuet dpend du compilateur ;

    de mme, au retour de la procdure, ltat dun pointeur associ dans la procdure largument muet est dpendant du compilateur.

    3 si largument muet a lattribut target et largument dappel na pas lattribut target ouest une section irrgulire 1 :

    tout pointeur associ largument muet dans la procdure devient indfini au retourde la dite procdure.

    1. Attention lutilisation de pointeurs globaux ou locaux permanents (save) ventuellementassocis dans la procdure cette cible dans le cas o le compilateur aurait dclench le mcanismede copy incopy out (cf. chapitre 5 page 83).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 153 / 317

    Pointeurs Passage dune cible en argument de procdure

    Passage dune cible en argument de procdure

    De plus, la norme 2008 prcise que si largument muet a lattribut pointer avec la vocationintent(in) et largument dappel a lattribut target, alors lentre de la procdure largumentmuet devient associ largument dappel comme le montre lexemple suivant :

    module sp_moduleimplicit none

    containssubroutine sp(p)

    real , dimension (:), pointer, intent(in) :: p

    if (associated(p)) print (*(f6.3) ,/), pend subroutine sp

    end module sp_module

    program mainuse sp_moduleimplicit nonereal , dimension (:), allocatable , target :: vec

    allocate(vec (10))call random_number(vec)print (*(f6.3),/), vec

    call sp(vec)deallocate(vec)

    end program main

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 154 / 317

  • Pointeurs Passage dune cible en argument de procdure

    Passage dune cible en argument de procdure

    Autre exemple

    module sp_moduleimplicit nonereal , dimension (:,:), pointer :: p

    containssubroutine sp(a)

    real , dimension (:,:), target :: a

    call random_number(a) ; p => aend subroutine sp

    end module sp_module

    program mainuse sp_moduleimplicit noneinteger n, mreal , dimension (:,:), allocatable , target :: a

    read (*,*) n, m ; allocate( a(n,m) )call sp(a(::2 ,:))do i=1,size(p,1)

    write( *, (*(f6.2))) p(i,:)end dodeallocate(a)

    end program main

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 155 / 317

    Pointeurs Pointeur, tableau profil diffr et COMMON

    Pointeur, tableau profil diffr et COMMON

    Exemple

    real ,allocatable ,dimension (:,:) :: P ! autoris depuis 2003real ,pointer , dimension (:,:) :: Preal ,target , dimension (10 ,10):: T1, T2, TABcommon /comm1/ P, T1,T2

    ...P => T1 ! associ avec un tableau du common

    ...P => TAB ! associ avec un tableau local

    ...allocate(P(50 ,90)) ! P : alias zone anonyme (50x90)

    Lattribut ALLOCATABLE est interdit pour un tableau figurant dans un COMMON. Quelle que soit lunit de programme o il se trouve, un pointeur appartenant unCOMMON doit forcment tre de mme type et de mme rang. Le nom importe peu. Ilpeut tre associ un tableau existant ou un tableau allou dynamiquement. Cetteassociation est connue par toute unit de programme possdant ce COMMON ;

    Attention : aprs chacune des deux dernires associations ci-dessus, seul le pointeurP fait partie du COMMON (pas la cible).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 156 / 317

  • Pointeurs Liste chane

    Liste chane

    Exemple : liste chane

    module Atype cel

    real , dimension (4) :: xcharacter(len =10) :: strtype(cel), pointer :: p => null()

    end type celtype(cel), pointer :: debut => null()

    containsrecursive subroutine listage(ptr)

    type(cel), pointer :: ptrif(associated(ptr%p)) call listage(ptr%p)print *, ptr%x, ptr%str

    end subroutine listagerecursive subroutine libere(ptr)

    type(cel), pointer :: ptrif(associated(ptr%p)) call libere(ptr%p)deallocate(ptr)

    end subroutine libereend module A

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 157 / 317

    Pointeurs Liste chane

    Exemple : liste chane (suite)

    program listeuse Aimplicit nonetype(cel), pointer :: ptr_courant , ptr_precedentdoif (.not.associated(debut)) thenallocate(debut) ; ptr_courant => debut

    elseallocate(ptr_courant ); ptr_precedent%p => ptr_courant

    end ifread *, ptr_courant%x, ptr_courant%strptr_precedent => ptr_courantif (ptr_courant%str == "fin") exit

    end docall listage(debut) ! => Impression de la dernire la 1re.call libere(debut) ! => Libration totale de la liste.

    end program liste

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 158 / 317

  • Interface de procdures et modules

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modulesInterface implicite : dfinitionInterface implicite : exempleArguments : attributs INTENT et OPTIONALPassage darguments par mot-clInterface explicite : procdure interneInterface explicite : 5 possibilitsInterface explicite : bloc interface

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 159 / 317

    Interface de procdures et modules

    Interface explicite : ses apportsInterface explicite : module et bloc interfaceInterface explicite : module avec procdureCas dinterface explicite obligatoireArgument de type procdural et bloc interface

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 160 / 317

  • Interface de procdures et modules Interface implicite : dfinition

    Interface implicite : dfinition

    Linterface de procdure est constitue des informations permettant la communicationentre deux procdures. Principalement :

    arguments dappel (actual arguments), arguments muets (dummy arguments), instruction function ou subroutine.

    En fortran 77Compte tenu du principe de la compilation spare des procdures et du passage desarguments par adresse, linterface contient peu dinformations do une visibilit trsrduite entre les deux procdures et donc des possibilits de contrle de cohrence trslimites. On parle alors dinterface implicite .

    En Fortran 90Interface implicite par dfaut entre deux procdures externes avec les mmesproblmes cf. exemple ci-aprs montrant quelques erreurs classiques non dtectes lacompilation.

    Lexemple suivant fait appel un sous-progr. externe maxmin pour calculer les valeursmax. et min. dun vecteur vect de taille n et optionnellement le rang rg_max de la valeurmax. avec mise--jour de la variable de contrle ctl.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 161 / 317

    Interface de procdures et modules Interface implicite : exemple

    Exemple

    program inoutimplicit noneinteger , parameter :: n=100real ,dimension(n) :: vreal :: xv,y

    ...call maxmin(v,n,vmax ,vmin ,control ,rgmax) ! OK!--->> Argument constante numrique : DANGER ...call maxmin(v,n,vmax ,vmin ,0,rgmax)nul =0; print *, nul=,nul!--->> Erreur de type et scalaire/tableaucall maxmin(xv,n,vmax ,vmin ,control ,rgmax)!--->> Interversion de deux argumentscall maxmin(v,n,vmax ,vmin ,rgmax ,control)!--->> "Oubli" de largument rg_maxcall maxmin(v,n,vmax ,vmin ,control)!--->> Argument y en tropcall maxmin(v,n,vmax ,vmin ,control ,rgmax ,y)

    end program inoutsubroutine maxmin(vect ,n,v_max ,v_min ,ctl ,rg_max)

    real ,dimension(n) :: vectV=v_max +... !-Erreur: v_max en sortie seulement.n=.... !-Erreur: n en entre seulementctl =99 !-Erreur: constante passe en argument.

    ...

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 162 / 317

  • Interface de procdures et modules Arguments : attributs INTENT et OPTIONAL

    Arguments : attributs INTENT et OPTIONAL

    Un meilleur contrle par le compilateur de la cohrence des arguments est possible enFortran 90 deux conditions :

    1 amliorer la visibilit de la fonction appele. Par exemple, en la dfinissant commeinterne (CONTAINS). On parle alors dinterface explicite .

    2 prciser la vocation des arguments muets de faon pouvoir contrler plus finementlusage qui en est fait. Pour ce faire, Fortran 90 a prvu :

    lattribut INTENT dun argument : INTENT(in) : entre seulement ; INTENT(out) : sortie seulement (dans la procdure, largument muet doit tre dfini avant

    toute rfrence cet argument) ; INTENT(inout) : entre et sortie.

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

    lattribut OPTIONAL pour dclarer certains arguments comme optionnels et pouvoirtester leur prsence ventuelle dans la liste des arguments dappel (fonction intrinsquePRESENT).

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 163 / 317

    Interface de procdures et modules Arguments : attributs INTENT et OPTIONAL

    Remarques

    lors de la dclaration des arguments muets dune procdure, la vocation(attribut INTENT) est interdite au niveau :

    de la valeur retourne par une fonction, dun argument de type procdural.

    INTENT(inout) nest pas quivalent labsence de vocation ; par exemple, uneconstante littrale ne peut jamais tre associe un argument muet ayant lattributINTENT(inout) alors quelle peut ltre largument sans vocation si ce dernier nestpas redfini dans la procdure ;

    un argument muet protg par la vocation INTENT(in) doit conserver cetteprotection dans les autres procdures auxquelles il est susceptible dtre transmis ;

    depuis la norme 2003, il est permis de prciser la vocation aux arguments muetsayant lattribut POINTER ; cest alors lassociation qui est concerne et non la cible :

    INTENT(IN) : le pointeur ne pourra ni tre associ, ni mis ltat nul, ni allou au seinde la procdure ;

    INTENT(OUT) : le pointeur est forc ltat indfini lentre de la procdure ; INTENT(INOUT) : le pointeur peut la fois transmettre une association prtablie et

    retourner une nouvelle association.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 164 / 317

  • Interface de procdures et modules Passage darguments par mot-cl

    Passage darguments par mot-cl

    lappel dune procdure, il est possible de passer des arguments par mots-cl ou depanacher avec des arguments positionnels. Pour la prise en compte des argumentsoptionnels, il est recommand dutiliser le passage par mots-cl. Le panachage restepossible sous deux conditions :

    1 les arguments positionnels doivent toujours prcder ceux mots-cl,2 parmi les arguments positionnels, seuls les derniers pourront alors tre omis sils sontoptionnels.

    Exemples supposant rg_max avec lattribut 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)

    Lexemple suivant fait appel au sous-programme maxmin avec interface explicite dufait de son utilisation comme procdure interne. Les erreurs de cohrence signalesplus haut seraient toutes dtectes la compilation.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 165 / 317

    Interface de procdures et modules Interface explicite : procdure interne

    Procdure interne

    Exemple

    program inoutimplicit noneinteger , parameter :: n=5integer :: rgmax=0,control =0real , dimension(n) :: v=(/ 1.,2.,9.,4.,-5. /)real :: vmax ,vmincall maxmin( v, vmax , vmin , control , rgmax )!---- Appel sans largument optionnel rgmaxcall maxmin( v, vmax , vmin , control )!---- Idem avec panachagecall maxmin( v, vmax , ctl=control , v_min=vmin )

    containssubroutine maxmin( vect ,v_max ,v_min,ctl,rg_max )

    real , dimension (:), intent(in) :: vectreal , intent(out) :: v_max , v_mininteger , optional , intent(out) :: rg_maxinteger , intent(inout) :: ctlv_max=MAXVAL(vect); v_min=MINVAL(vect); ctl=1if( present(rg_max) ) then

    rg_max=MAXLOC(vect , DIM =1); ctl=2end if

    end subroutine maxminend program inout

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 166 / 317

  • Interface de procdures et modules Interface explicite : procdure interne

    Expliciter linterface via une procdure interne est une solution simple et permet bien dersoudre la compilation tous les cas derreurs signals. Elle prsente nanmoins desinconvnients qui en limitent lutilisation :

    la procdure interne nest pas visible de lextrieur, programmation lourde et non modulaire.

    Nous verrons plus loin quil existe cinq solutions pour profiter de la fiabilit associe linterface explicite.Remarques

    il nest pas possible dimbriquer les procdures internes ; linstruction CONTAINS nepeut appratre quune seule fois ;

    les procdures internes et la procdure les contenant forment une mme et uniquescoping unit ;

    linstruction IMPLICIT NONE prcise pour une procdure sapplique galement sesprocdures internes ;

    si linstruction IMPLICIT NONE est spcifie dans la partie data (specificationpart) dun module, celle-ci nest pas exportable via linstruction USE ;

    dans une procdure interne, une variable dj prsente dans lappelant est : globale si elle nest pas explicitement redclare, locale si elle est explicitement redclare.

    Do lintrt particulier de prciser linstruction IMPLICIT NONE pour desprocdures avant leur conversion en procdures internes Fortran 90. La ncessit detout dclarer vite alors le risque de globaliser tort des variables localeshomonymes.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 167 / 317

    Interface de procdures et modules Interface explicite : 5 possibilits

    Interface explicite : 5 possibilits

    1 procdures intrinsques (Fortran 77 et Fortran 95),2 procdures internes (CONTAINS),3 prsence du bloc interface dans la procdure appelante,4 la procdure appelante accde (USE) au module contenant le bloc interface de laprocdure appele,

    5 la procdure appelante accde (USE) au module contenant la procdure appele.

    Le cas 2 a dj t trait et comment dans lexemple prcdent ; les cas 3, 4 et 5 serontexploits ci-aprs en adaptant ce mme exemple.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 168 / 317

  • Interface de procdures et modules Interface explicite : bloc interface

    Interface explicite avec bloc interface

    Pour viter les inconvnients de la procdure interne tout en conservant la fiabilit delinterface explicite , Fortran 90 offre la solution du bloc interface qui permet dedonner l o il est prsent une visibilit complte sur linterface dune procdure externe.Ce bloc interface peut tre cr par copie de la partie dclarative des arguments muets dela procdure interfacer. Il sera insr dans chaque unit de programme faisant rfrence la procdure externe.

    Avec cette solution la procdure reste bien externe (modularit), mais il subsiste lancessit de dupliquer le bloc interface (dans chaque procdure appelante) avec lesrisques que cela comporte... Par ailleurs le contrle de cohrence est fait entre lesarguments dappel et les arguments muets dfinis dans le bloc interface et non pas ceuxde la procdure elle-mme !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 169 / 317

    Interface de procdures et modules Interface explicite : bloc interface

    Exemple avec bloc interface

    program inoutimplicit noneinteger ,parameter :: n=5integer :: rgmax=0,control =0real ,dimension(n) :: v=(/ 1. ,2.,40.,3.,4. /)real :: vmax ,vmin!-------- Bloc interface -------------------------interfacesubroutine maxmin( vect , v_max , v_min , ctl , rg_max )real ,dimension (:), intent(in) :: vectreal , intent(out) :: v_max ,v_mininteger , optional , intent(out) :: rg_maxinteger , intent(inout) :: ctl

    end subroutine maxminend interface!------------------------------------------------.......call maxmin( v, vmax , vmin , control , rgmax ).......

    end program inout

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 170 / 317

  • Interface de procdures et modules Interface explicite : bloc interface

    Exemple avec bloc interface (suite)

    subroutine maxmin( vect , v_max , v_min , ctl , rg_max )implicit nonereal ,dimension (:), intent(in) :: vectreal , intent(out) :: v_max ,v_mininteger , optional , intent(out) :: rg_maxinteger , intent(inout) :: ctlv_max = MAXVAL(vect)v_min = MINVAL(vect)ctl = 1if( present(rg_max) ) then

    rg_max = MAXLOC( vect , DIM=1 )ctl = 2

    endifprint *,"Taille vecteur via size :",SIZE(vect)print *,"Profil vecteur via shape:",SHAPE(vect)

    end subroutine maxmin

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 171 / 317

    Interface de procdures et modules Interface explicite : ses apports

    Interface explicite : ses apports

    la transmission du profil et de la taille des tableaux profil implicite et la possibilitde les rcuprer via les fonctions SHAPE et SIZE,

    la possibilit de contrler la vocation des arguments en fonction des attributsINTENT et OPTIONAL : en particulier linterdiction de passer en argument dappel uneconstante (type PARAMETER ou numrique) si largument muet correspondant a lavocation OUT ou INOUT,

    la possibilit de tester labsence des arguments optionnels (fonction PRESENT), le passage darguments par mot-cl, la dtection des erreurs lies la non cohrence des arguments dappel et desarguments muets (type, attributs et nombre) ; consquence frquente dune faute defrappe, de loubli dun argument non optionnel ou de linterversion de deuxarguments.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 172 / 317

  • Interface de procdures et modules Interface explicite : module et bloc interface

    Interface explicite : module et bloc interface

    Pour amliorer la fiabilit gnrale du programme et sassurer dune parfaite homognitdu contrle des arguments il faut insrer le mme bloc interface dans toutes les units deprogramme faisant rfrence la procdure concerne (le sous-programme maxmin dansnotre exemple).Cest l le rle du module et de linstruction USE permettant laccs son contenu dansune unit de programme quelconque.Un module est une unit de programme particulire introduite en Fortran 90 pourencapsuler entre autres :

    des donnes et des dfinitions de types drivs, des blocs interfaces, des procdures (aprs linstruction CONTAINS),

    Quel que soit le nombre daccs (USE) au mme module, les entits ainsi dfinies sontuniques (remplace avantageusement la notion de COMMON).Doit tre compil sparment avant de pouvoir tre utilis.Afin de raliser une interface explicite , les exemples suivant font lutilisation dunmodule renfermant le bloc interface dans le 1er puis la procdure elle-mme (solution laplus sre).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 173 / 317

    Interface de procdures et modules Interface explicite : module et bloc interface

    Exemple avec module et bloc interface

    module bi_maxmininterfacesubroutine maxmin(vect ,v_max ,v_min ,ctl ,rg_max)

    real ,dimension (:), intent(in) :: vectreal , intent(out) :: v_max ,v_mininteger , optional , intent(out) :: rg_maxinteger , intent(inout ):: ctl

    end subroutine maxminend interface

    end module bi_maxmin

    Ce module est compil sparment et stock dans une bibliothque personnelle demodules. Son utilisation ultrieure se fera comme dans lexemple ci-dessous :program inout

    USE bi_maxmin !

  • Interface de procdures et modules Interface explicite : module avec procdure

    Exemple avec module procdure

    module mpr_maxmincontainssubroutine maxmin(vect ,v_max ,v_min ,ctl ,rg_max)implicit nonereal ,dimension (:), intent(in) :: vectreal , intent(out) :: v_max ,v_mininteger , optional , intent(out) :: rg_maxinteger , intent(inout) :: ctlv_max=MAXVAL(vect) ; v_min=MINVAL(vect)ctl=1if(present(rg_max ))then

    rg_max=MAXLOC(vect , DIM =1); ctl=2endif

    end subroutine maxminend module mpr_maxmin

    Aprs compilation spare du module, on lutilisera comme suit :program inout

    USE mpr_maxmin !

  • Interface de procdures et modules Cas dinterface explicite obligatoire

    Exemple de fonctions valeur tableau/pointeur/chane

    module M1implicit none

    containsfunction f_t(tab) !

  • Interface de procdures et modules Cas dinterface explicite obligatoire

    Remarque la norme Fortran interdit la re-spcification de lun quelconque des attributs(hormis PRIVATE ou PUBLIC) dune entit vue par USE association . Le type, partieintgrante des attributs, est concern :Exemple

    module Acontains

    function f(x)implicit nonereal , intent(in) :: xreal :: ff=-sin(x)

    end function fend module A

    program pg1USE A !

  • Interface de procdures et modules Argument de type procdural et bloc interface

    Exemple (suite)

    program Puse fctimplicit nonereal , dimension (10) :: t; real x

    . . .x = myfonc( tab=t, f=f1) ! avec arg. dappel f1x = myfonc( tab=t, f=f2) ! avec arg. dappel f2

    . . .

    Cest la seule solution pour fiabiliser lappel de f dans myfonc. Ne pas dclarer f1 et f2comme EXTERNAL dans le programme P et ne pas exporter le bloc interface par useassociation.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 181 / 317

    Interface gnrique

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnriqueIntroductionExemple avec module procedureExemple : contrle de procdure F77

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 182 / 317

  • Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 183 / 317

    Interface gnrique Introduction

    Interface gnrique : introduction

    Possibilit de regrouper une famille de procdures sous un nom gnrique dfini via unbloc interface nomm. lappel de la fonction gnrique, le choix de la procdure excuter est fait automatiquement par le compilateur en fonction du nombre et du typedes arguments.

    Cette notion existe en Fortran 77, mais reste limite aux fonctions intrinsques : selon letype de x, pour valuer abs(x), le compilateur choisit (notion de fonction gnrique) :

    iabs(x) si x entier, abs(x) si x rel simple prcision, dabs(x) si x rel double prcision, cabs(x) si x complexe simple prcision.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 184 / 317

  • Interface gnrique Exemple avec module procedure

    Dfinition dune fonction gnrique maxmin sappliquant aux vecteurs quils soient detype rel ou de type entier deux sous-programmes trs voisins :

    rmaxmin si vect rel, imaxmin si vect entier,

    Nous allons successivement :1 crer les deux sous-programmes rmaxmin et imaxmin,2 les stocker dans un module big_maxmin,3 stocker dans ce mme module un bloc interface familial de nom maxmin rfrenantles 2 sous-programmes via linstruction : MODULE PROCEDURE rmaxmin, imaxmin

    4 compiler ce module pour obtenir son descripteur (big_maxmin.mod) et son moduleobjet,

    5 crer un exemple dutilisation en prenant soin de donner accs (via USE) au modulecontenant linterface gnrique en tte de toute unit de programme appelant lesous-programme maxmin.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 185 / 317

    Interface gnrique Exemple avec module procedure

    Exemple avec module procdure

    module big_maxmininterface maxmin

    module procedure rmaxmin ,imaxmin !

  • Interface gnrique Exemple avec module procedure

    Exemple avec module procdure (suite)

    program pUSE big_maxmin !

  • Interface gnrique Exemple : contrle de procdure F77

    Contrle de procdure F77 via interface gnrique et explicite

    . . .

    . . . Module objetFortran 77

    call SP(...)"SP"

    Figure 2 : appel classique dun sous-progr. SP disponible sous forme dun module objet sanscontrle inter-procdural

    Bloc interfacede

    "SP"

    Module objetFortran 77

    "SP"

    . . .call. . .

    SP(...)

    Figure 3 : idem en contrlant le passage darguments via un bloc interface

    Bloc interfacegenerique

    Sousprogr. Module objetFortran 77

    . . .

    . . ."SP"

    "control_SP"

    call SP(...)"SP"

    Figure 4 : idem en utilisant un bloc interface gnrique SP appelant un sous-programmecontrol_SP contrlant lappel de SP avec la notion darguments optionnels et de valeurs pardfaut associes (cf. exemple ci-aprs).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 189 / 317

    Interface gnrique Exemple : contrle de procdure F77

    Exemple

    SUBROUTINE SP(X,I,J)J=I+XWRITE (6,*) "*** SP (F77) *** : X, I, J=", X, I, JEND

    !------------------------------------------------module mod1contains

    subroutine control_SP(arg1 ,arg2 ,arg3)implicit nonereal , intent(in) :: arg1integer , intent(inout),optional :: arg2integer , intent(out) :: arg3integer :: my_arg2if(.not. present(arg2)) then !-------------------

    my_arg2 = 1 !"arg2 =1" interdit !else !-------------------

    my_arg2 = arg2end if !-------------------call SP(arg1 , my_arg2 , arg3) !Appel NON gnrique

    end subroutine control_SP !-------------------end module mod1

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 190 / 317

  • Interface gnrique Exemple : contrle de procdure F77

    Exemple (suite)

    module module_genericuse mod1interface SP !-----------------module procedure control_SP !Bloc interface SP

    end interface SP !-----------------end module module_generic!------------------------------------------------program prog

    use module_genericimplicit nonereal :: x=88.integer :: j !------------------call SP(arg1=x,arg3=j) !

  • Interface gnrique Exemple : contrle de procdure F77

    Autre solution (suite)

    program proguse module_genericimplicit nonereal :: x=88.integer :: j !-----------------call SP(arg1=x,arg3=j) !

  • Surcharge ou cration doprateurs

    Interface assignment

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 195 / 317

    Surcharge ou cration doprateurs Introduction

    Surcharge doprateurs - Introduction

    Certaines notions propres aux langages orients objets ont t incluses dans la normeFortran 90 notamment la possibilit de surcharger les oprateurs pr-dfinis du langage.Surcharger ou sur-dfinir un oprateur cest largir son champ dapplication endfinissant de nouvelles relations entre objets.

    Lors de la surcharge dun oprateur, on doit respecter sa nature (binaire ou unaire). Deplus il conserve sa priorit dfinie par les rgles de prcdence du langage.

    Lorsque lon applique un oprateur des expressions, une valeur est retourne. Onemploiera donc des procdures de type function pour surcharger un tel oprateur.

    Par contre, le symbole daffectation (=), ne retournant aucune valeur, doit tresur-dfini laide dune procdure de type subroutine.

    De plus, la norme permet la dfinition de nouveaux oprateurs.

    Il est bon de noter que le symbole daffectation (=) ainsi que certains oprateursarithmtiques et logiques ont dj fait lobjet dune sur-dfinition au sein du langage.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 196 / 317

  • Surcharge ou cration doprateurs Introduction

    exemple

    implicit noneinteger(kind=2), parameter :: p = selected_int_kind (2)integer(kind=p) :: ireal , dimension (3,3) :: a,b,clogical , dimension (3,3) :: ltype vecteur

    real(kind =8) :: x,y,zend type vecteurtype(vecteur) :: u,v!------------------------------v = vecteur( sqrt (3.)/2. ,0.25 ,1. )a = reshape( (/ (i,i=1,9) /), shape=shape(a) )b = reshape( (/ (i**3,i=1,9) /), shape=shape(b) )

    ...c = bu = vl = a == bif (a == b)... ! Incorrect POURQUOI ?l = a < bc = a - bc = a * b

    ...

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 197 / 317

    Surcharge ou cration doprateurs Interface operator

    Surcharge doprateurs - Interface operator

    Pour surcharger un oprateur on utilisera un bloc interface operator. la suite dumot-cl operator on indiquera entre parenthses le signe de loprateur surcharger.Pour dfinir un nouvel oprateur, cest le nom (de 1 31 lettres) quon lui aura choisiencadr du caractre . qui figurera entre parenthses.Voici un exemple de surcharge de loprateur + :

    exemple

    module matriximplicit nonetype OBJ_MAT

    integer :: n,m! Attribut allocatable possible depuis Fortran 2003 :real , dimension (:,:), allocatable :: mat

    end type OBJ_MATinterface operator (+)

    module procedure addend interface

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 198 / 317

  • Surcharge ou cration doprateurs Interface operator

    exemple (suite)

    containsfunction add(a,b)

    type(OBJ_MAT), intent(in) :: a,btype(OBJ_MAT) :: add

    add%n = a%n; add%m = a%mallocate(add%mat(add%n,add%m))add%mat = a%mat + b%mat

    end function addend module matrix

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 199 / 317

    Surcharge ou cration doprateurs Interface operator

    exemple (suite)

    program appeluse matriximplicit noneinteger :: i, j, n, mtype(OBJ_MAT) :: u, v, w

    print *,Entrer la valeur de n :read (*,*)n; u%n = n; v%n = nprint *,Entrer la valeur de m :read (*,*)m; u%m = m; v%m = mallocate(u%mat(n,m))allocate(v%mat(n,m))u%mat = reshape( source =(/ ((real(i+j),i=1,n),j=1,m) /), &

    shape=shape(u%mat))v%mat = reshape( source =(/ ((real(i*j),i=1,n),j=1,m) /), &

    shape=shape(v%mat))w = u + v !

  • Surcharge ou cration doprateurs Interface assignment

    Surcharge doprateurs - Interface assignment

    Pour surcharger le symbole daffectation (=), utiliser un bloc interface interfaceassignment. la suite du mot-cl assignment on indiquera entre parenthses lesymbole daffectation, savoir =.Voici un exemple de surcharge du symbole daffectation et de dfinition dun nouveloprateur :

    exemple

    module matriximplicit nonetype OBJ_MAT

    integer :: n,m! Attribut allocatable possible depuis Fortran 2003 :real , dimension (:,:), allocatable :: mat

    end type OBJ_MATinterface operator (+) ! Surcharge de

    module procedure add ! loprateur +end interfaceinterface operator (.tr.) ! Dfinition

    module procedure trans ! de loprateur .tr.end interfaceinterface assignment (=) ! Surcharge de

    module procedure taille_mat ! laffectationend interface

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 201 / 317

    Surcharge ou cration doprateurs Interface assignment

    exemple

    contains! Fonction associe loprateur +function add(a,b)

    . . .end function add! Fonction associe loprateur .tr.function trans(a)

    type(OBJ_MAT), intent(in) :: atype(OBJ_MAT) :: trans

    trans%n = a%m;trans%m = a%nallocate(trans%mat(trans%n,trans%m))trans%mat = transpose(a%mat)

    end function trans! Sous -programme associ laffectation (=)subroutine taille_mat(i,a)

    integer , intent(out) :: itype(OBJ_MAT), intent(in) :: a

    i = a%n*a%mend subroutine taille_mat

    end module matrix

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 202 / 317

  • Surcharge ou cration doprateurs Interface assignment

    exemple

    program appeluse matriximplicit nonetype(OBJ_MAT) :: u, v, w, tinteger :: taille_u , taille_v , n, m

    ...read *, n, mallocate(u%mat(n,m), v%mat(n,m), w%mat(n,m))

    ...!-----------taille_u = utaille_v = v!-----------t = .tr.w

    end program appel

    Remarques Lors de la sur-dfinition dun oprateur, le ou les arguments de la fonction associedoivent avoir lattribut intent(in) ;

    Lors de la sur-dfinition du symbole daffectation, le 1erargument (oprande degauche) doit avoir lattribut intent(out) ou intent(inout) et le 2e (oprande dedroite), lattribut intent(in) ;

    Les symboles => (pointer assignment symbol) et % (rfrence une composante destructure) ne peuvent tre surchargs.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 203 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 204 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    IntroductionInstructions PRIVATE et PUBLICAttributs PRIVATE et PUBLICType driv semi-privExemple avec contrle de la visibilitParamtre ONLY de linstruction USE

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 205 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Introduction

    Introduction

    Le concepteur dun module a la possibilit de limiter laccs aux ressources (variables,constantes symboliques, dfinitions de type, procdures) quil se dfinit lintrieur decelui-ci. Il pourra par exemple cacher et donc rendre non exportables (via linstructionuse) certaines variables et/ou procdures du module.

    Ceci peut se justifier lorsque certaines ressources du module ne sont ncessaires qulintrieur de celui-ci. De ce fait, le concepteur se rserve le droit de les modifier sans queles units utilisatrices externes ne soient impactes.

    Cela permettra galement dviter les risques de conflits avec des ressources dautresmodules.

    Ces ressources non exportables sont dites prives. Les autres sont dites publiques.

    Par dfaut, toutes les ressources dun module (variables, procdures) sont publiques.

    La privatisation de certaines donnes (concept dencapsulation de donnes) conduit leconcepteur fournir au dveloppeur des mthodes (procdures publiques) facilitant lamanipulation globale dobjets privs ou semi-privs. Leur documentation et leurfourniture est un aspect important de la programmation objet.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 206 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Instructions PRIVATE et PUBLIC

    Instructions PRIVATE et PUBLIC

    lentre dun module le mode par dfaut est le mode PUBLIC.

    Les instructions PRIVATE ou PUBLIC sans argument permettent respectivement dechanger de mode ou de confirmer le mode par dfaut ; ce mode sapplique alors toutesles ressources de la partie donnes (specification part) du module.

    Ce type dinstruction ne peut apparatre quune seule fois dans un module.

    Exemple

    module donneeinteger , save :: i ! privereal , dimension (:), pointer :: ptr ! priveprivatecharacter(len =4) :: car ! prive

    end module donnee

    module modpubliclogical , dimension (:), allocatable :: mask ! publique

    ...end module mod

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 207 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Attributs PRIVATE et PUBLIC

    Attributs PRIVATE et PUBLIC

    On peut dfinir le mode dune ressource dun module au moyen de lattribut PRIVATE ouPUBLIC indiqu sa dclaration.Bien distinguer :

    linstruction PRIVATE ou PUBLIC sans argument qui permet de dfinir le mode devisibilit,

    cette mme instruction laquelle on spcifie une liste dobjets auquel cas ce sont cesobjets qui reoivent lattribut indiqu.

    Exemple

    module donneeprivateinteger , public :: i, j ! publiquereal :: x, y, z ! y,z : privespublic :: x ! publiquepublic :: sp

    containssubroutine sp(a,b) ! publique

    ...end subroutine splogical function f(x) ! prive

    ...end function f

    end module donnee

    Note : pour dclarer la variable x publique il serait prfrable de coder : real, public :: x

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 208 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Type driv semi-priv

    Type driv semi-priv

    Les attributs prcdents peuvent galement sappliquer aux types drivs.Un type driv peut tre :

    public ainsi que ses composantes, on parle alors de type driv transparent. priv public mais avec toutes ses composantes prives. On parle alors de type driv semi-priv .

    Lintrt du type driv semi-priv est de permettre au concepteur du module lecontenant den modifier sa structure sans en affecter les units utilisatrices.

    Par dfaut les composantes dun type driv public sont publiques.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 209 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Type driv semi-priv

    Exemple

    MODULE modprivate :: t4!-------------------------------type t1 ! semi -priv

    private. . . . . .

    end type t1!-------------------------------type , private :: t2 ! priv

    . . . . . .end type t2!-------------------------------type t3 ! public

    . . . . . .end type t3!-------------------------------type t4 ! priv

    . . . . . .end type t4!-------------------------------. . . . . .

    END MODULE mod

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 210 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Exemple complet de cration dun module au sein duquel on dfinit : des variables globales (ici nb_lignes et nb_colonnes alternative au COMMON), un type-driv OBJ_MAT semi-priv, certaines ressources prives, des procdures de surcharge/dfinition doprateurs, des mthodes (poubelle, imp).

    Exemple

    module matrixinteger :: nb_lignes =0, nb_colonnes =0!type OBJ_MAT

    private! Initialisation des composantes possible depuis Fortran 95 :integer :: n=0,m=0! Attribut allocatable possible depuis Fortran 2003 :real ,dimension (:,:), allocatable :: mat

    end type OBJ_MAT!private :: valorisation ,add ,taille_mat ,trans!-------------------------------------------interface operator (+)

    module procedure addend interface

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 211 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Exemple (suite)

    interface operator (.tr.)module procedure trans

    end interface!------------------------------------------interface assignment (=)

    module procedure taille_mat , valorisationend interface!------------------------------------------

    containssubroutine valorisation(a,t)

    type(OBJ_MAT), intent(inout) :: areal , dimension (:), intent(in) :: t

    if ( nb_lignes

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Exemple (suite)

    subroutine affectationreal , dimension(size(a%mat)) :: remplissage

    remplissage = 0.a%mat = reshape( source = t, &

    shape = shape(a%mat), &pad = remplissage )

    end subroutine affectationend subroutine valorisation!--------------------------------subroutine poubelle(a)

    type(OBJ_MAT), intent(inout) :: a

    if (allocated(a%mat)) thena%n = 0; a%m = 0; deallocate(a%mat)

    endifend subroutine poubelle!--------------------------------function add(a,b)

    type(OBJ_MAT), intent(in) :: a, btype(OBJ_MAT) :: add

    allocate(add%mat(a%n,a%m))add%n = a%n; add%m = a%m; add%mat = a%mat + b%mat

    end function add

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 213 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Exemple

    subroutine taille_mat(i,a)integer , intent(out) :: itype(OBJ_MAT), intent(in) :: ai = a%n*a%m

    end subroutine taille_mat!--------------------------------function trans(a)

    type(OBJ_MAT), intent(in) :: atype(OBJ_MAT) :: transallocate(trans%mat(a%m, a%n))trans%n=a%m; trans%m=a%n; trans%mat=transpose(a%mat)

    end function trans!--------------------------------subroutine imp(a)

    type(OBJ_MAT), intent(in) :: ainteger(kind =2) :: iif ( .not.allocated(a%mat) ) then

    print *,"Impression : objet inexistant."; stop 16end ifdo i=1,size(a%mat ,1)

    print *,a%mat(i,:)enddo

    end subroutine impend module matrix

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 214 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Exemple dunit utilisatrice de ce module

    program appeluse matriximplicit noneinteger :: i, j, tailletype(OBJ_MAT) :: u, v, w, t

    print *,"Nb. de lignes : "; read *, nb_lignesprint *,"Nb. de colonnes :"; read *, nb_colonnesu = (/ ((real(i+j),i=1,nb_lignes),j=1, nb_colonnes) /)v = (/ ((real(i*j),i=1,nb_lignes),j=1, nb_colonnes) /)

    ...u=v ! Voir remarques ci-aprs.

    ...call imp(u) ; call imp(v)call poubelle(v)taille = w ; call imp(w)call poubelle(w)t = .tr. u ; call imp(t)call poubelle(u)call poubelle(t)

    end program appel

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 215 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Remarques

    concernant laffectation u = v, bien que celle-ci ait un sens il peut tre intressantden avoir la totale matrise dans le but deffectuer un certain nombre de contrles :pour cela on surcharge le symbole daffectation. Sur la page suivante, on a doncajout au sein du bloc interface assignment(=) un sous-programme affectque lon dfinit ensuite ;

    les objets de type OBJ_MAT retourns par les fonctions telles que add et trans sonttemporaires : lors de leur disparition en mmoire, gre par le compilateur, la normeFortran 2003 prcise que les composantes ayant lattribut ALLOCATABLE (ici mat)sont automatiquement dsalloues ;

    dans le cas o lattribut POINTER tait indiqu la place de ALLOCATABLE pour cettecomposante, la gestion mmoire aurait t sous la responsabilit du programmeur :pour ce faire celui-ci dispose de procdures spcifiques appeles final procedure. Sereporter au cours Fortran 2003 pour plus de prcisions.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 216 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Exemple avec contrle de la visibilit

    Solution avec redfinition de laffectation

    module matrixinterface assignment (=)

    module procedure taille_mat , valorisation , affectend interface

    !--------------------------------contains

    . . . . .subroutine affect(a,b)

    type(OBJ_MAT), intent(inout) :: atype(OBJ_MAT), intent(in) :: bif (.not.allocated(b%mat)) &

    stop "Erreur : membre de droite de &&laffectation non initialis"

    if (allocated(a%mat)) thenif (any(shape(a%mat) /= shape(b%mat))) &

    stop "Erreur : affect. matrices non conformantes"else

    allocate(a%mat(b%n,b%m), stat=etat)if (etat /= 0) &

    stop "Erreur ==> allocation membre de gauche"! Il est parfois prfrable de laisser le compilateur grer! lerreur pour rcuprer la "traceback" ventuellement plus! informative. Dans ce cas , ne pas spcifier stat=etat .

    end ifa%n = b%n ; a%m = b%m ; a%mat = b%mat

    end subroutine affect. . . . .

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 217 / 317

    Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Paramtre ONLY de linstruction USE

    Paramtre ONLY de linstruction USE

    De mme que le concepteur dun module peut cacher des ressources de ce module, uneunit utilisatrice de celui-ci peut sinterdire laccs certaines dentre elles.Pour cela on utilise le paramtre only de linstruction use.

    Exemple

    module mtype t1...

    end type t1type t2...

    end type t2logical , dimension (9) :: l

    containssubroutine sp(...)

    ...end subroutine spfunction f(...)

    ...end function f

    end module m

    program utiluse m,only : t2,f ! Seules les ressources t2 et f sont exportes

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 218 / 317

  • Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques Paramtre ONLY de linstruction USE

    Lors de lutilisation dun module, on peut tre gn par les noms des ressources quil nouspropose, soit parce que dans lunit utilisatrice il existe des ressources de mme nom oubien parce que les noms proposs ne nous conviennent pas.Dans ce cas, il est possible de renommer les ressources du module au moment de sonutilisation via le symbole => que lon spcifie au niveau de linstruction use. La norme2003 permet de plus le renommage des oprateurs non intrinsques.

    Exemple

    use m, mon_t2=>t2 , mon_f=>fuse m, only : mon_t2=>t2 , mon_f=>fuse m, OPERATOR (. MY_OPER .) => OPERATOR (.OPER.) ! Fortran 2003

    Remarque on notera lanalogie entre ce type de renommage et laffectation des pointeurs.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 219 / 317

    Procdures rcursives

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 220 / 317

  • Procdures rcursives

    12 Procdures rcursivesClauses RESULT et RECURSIVEExemple : suite de Fibonacci

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 221 / 317

    Procdures rcursives Clauses RESULT et RECURSIVE

    Clauses RESULT/RECURSIVE

    En Fortran 90 on peut crire des procdures (sous-programmes ou fonctions) rcursives.

    Dfinition :

    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)

    Attention : dans le cas dune fonction rcursive, pour que lemploi du nom de la fonctiondans le corps de celle-ci puisse indiquer un appel rcursif, il est ncessaire de dfinir unevariable rsultat par lintermdiaire de la clause RESULT lors de la dfinition de la fonction.

    Remarques le type de la variable rsultat est toujours celui de la fonction, possibilit dutiliser la clause RESULT pour les fonctions non rcursives.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 222 / 317

  • Procdures rcursives Exemple : suite de Fibonacci

    Suite de Fibonacci

    u0 = 1 u1 = 1 u2 = 2 . . . . un = un1 + un2

    Exemple : suite de Fibonacci

    recursive function fibonacci(n) result(fibo)integer , intent(in):: ninteger :: fibointeger , save :: penult , antepenult!------------------------------------------------if (n Test darrt (On dpile)

    fibo = 1antepenult = 1 ; penult = 1

    !------------------------------------------------else !--> Bloc rcursif dempilement dans la pile (stack)

    fibo = fibonacci(n-1); fibo = fibo + antepenultantepenult = penult ; penult = fibo

    end ifend function fibonacci

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 223 / 317

    Procdures rcursives 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 dfinitionmathmatique de la suite. Bien que parfaitement valide, cette dernire solutionserait prohibitive en terme de performance car elle empilerait deux appels rcursifs(au lieu dun seul) et conduirait recalculer de trs nombreux termes dj valus !

    2 Une autre possibilit serait de programmer sous la forme :fibo = fibonacci(n-1) + antepenult qui est une expression interdite par lanorme Fortran 95 ! En effet, dans une expression, lappel dune fonction na pas ledroit de modifier une entit (ici la variable locale antepenult avec lattribut SAVE)intervenant dans cette expression. De plus, lappel de la fonction fibonacci doitobligatoirement prcder le cumul de antepenult dans fibo do le dcoupage endeux instructions.

    Note : pour un exemple de sous-programme rcursif, cf. page 159

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 224 / 317

  • Nouveauts sur les E/S

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 225 / 317

    Nouveauts sur les E/S

    12 Procdures rcursives

    13 Nouveauts sur les E/SAccs aux fichiers pr-connectsOPEN (status, position, pad, action, delim)INQUIRE (recl, action, iolength,...)Entres-sorties sur les fichiers texte (advance=no)Paramtres IOSTAT et IOMSG de linstruction READParamtres IOSTAT et IOMSG de linstruction READInstruction NAMELISTSpcification de format minimum

    14 Nouvelles fonctions intrinsques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 226 / 317

  • Nouveauts sur les E/S Accs aux fichiers pr-connects

    Accs aux fichiers pr-connects

    Le compilateur Fortran 2003 est livr avec plusieurs modules intrinsques tel queISO_FORTRAN_ENV qui contient des constantes symboliques permettant notamment lerfrencement des fichiers pr-connects :

    INPUT_UNIT, OUTPUT_UNIT et ERROR_UNIT sont des entiers correspondant auxnumros des units logiques relatifs lentre standard, la sortie standardet la sortie derreur. Ils remplacent avantageusement lastrisque employtraditionnellement au niveau du paramtre UNIT des instructions READ/WRITE ;

    IOSTAT_END et IOSTAT_EOR sont des entiers correspondant aux valeurs ngativesprises par le paramtre IOSTAT des instructions dentre/sortie en cas de fin defichier ou de fin denregistrement. Cela permet denrichir la portabilit dun codeFortran. Cependant, les cas derreurs gnrent une valeur positive restantdpendante du constructeur.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 227 / 317

    Nouveauts sur les E/S OPEN (status, position, pad, action, delim)

    Instruction OPEN

    1 NEWUNIT= ce nouveau mot-cl, introduit par la norme 2008, permet de spcifier une variable

    entire qui sera valorise lissue de lOPEN un numro dunit logique ninterfrantpas avec ceux dj employs, notamment ceux concernant les fichiers pr-connects ;

    2 STATUS= REPLACE : si le fichier nexiste pas, il sera cr, sinon il sera dtruit et un fichier de

    mme nom sera cr.3 POSITION=

    REWIND : indique que le pointeur du fichier sera positionn son dbut ; 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 dj connect. Cest utile lorsque lon dsire (via linstruction OPEN)modifier certaines caractristiques du fichier tout en restant positionn (valeur pardfaut). Trs limitatif et dpendant du constructeur !

    4 PAD= YES : des enregistrements lus avec format sont complts avec des blancs (padding)

    dans le cas o la liste de variables trater et le format correspondant ncessitent plusde caractres que lenregistrement nen contient. (valeur par dfaut).

    NO : pas de padding.5 ACTION=

    READ : toute tentative dcriture est interdite ; WRITE : toute tentative de lecture est interdite ; READWRITE : les oprations de lecture et criture sont autorises (valeur par dfaut).

    6 DELIM= ce paramtre permet de dlimiter les chanes de caractres crites pardes namelist ou en format libre :

    APOSTROPHE : indique que lapostrophe sera utilise ; QUOTE : indique que le guillemet " sera utilise ; NONE : indique quaucun dlimiteur ne sera utilis (valeur par dfaut).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 228 / 317

  • Nouveauts sur les E/S INQUIRE (recl, action, iolength,...)

    Instruction INQUIRE

    RECL=n : permet de rcuprer la longueur maximale des enregistrements. POSITION=chane : permet de rcuprer la valeur du mme paramtre spcifi lorsde lopen.

    ACTION=chane : permet de rcuprer la valeur du mme paramtre spcifi lors delopen.

    DELIM=chane : permet de rcuprer la valeur du mme paramtre spcifi lors delopen.

    IOLENGTH=long : permet de rcuprer la longueur de la liste des entits spcifies.Cest utile lorsque lon veut valoriser le paramtre RECL de lordre OPEN pour unfichier binaire accs direct.

    PAD=chane : permet de rcuprer la valeur du mme paramtre spcifi lors delOPEN.

    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 : largument IOLENGTH de linstruction INQUIRE permet de connatre la longueur(E./S. binaires) dune structure de type driv (sans composante pointeur) faisant partiede la liste spcifie.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 229 / 317

    Nouveauts sur les E/S Entres-sorties sur les fichiers texte (advance=no)

    Entres-sorties sur les fichiers texte (advance=no)

    Le paramtre ADVANCE=no des instructions READ/WRITE (ADVANCE=yes par dfaut)permet de rester positionner sur lenregistrement courant.Dans le cas dune lecture avec format explicite et en prsence du paramtreADVANCE=no :

    le paramtre EOR=nnn effectue un transfert ltiquette nnn lorsquune findenregistrement est dtecte ;

    le paramtre SIZE=long ( long variable de type INTEGER) de linstruction READpermet de rcuprer le nombre de caractres transfrs lors de la lecture. Dans le caso la fin denregistrement est dtecte, ce nombre ne tient pas compte du paddingsi padding il y a (paramtre PAD valoris yes lors de lOPEN).

    Note : ADVANCE=no est incompatible avec le format libre.Une alternative aux paramtres END=nnn et EOR=nnn de linstruction READ est lemploi duparamtre IOSTAT. Il retourne un entier :

    positif en cas derreur ; ngatif lorsquune fin de fichier ou une fin denregistrement est atteinte (valeursdpendant du constructeur) ;

    nul sinon.Exemple

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 230 / 317

  • Nouveauts sur les E/S Entres-sorties sur les fichiers texte (advance=no)

    Exemple

    character(len =1) :: c!-----------------------------------------------! Lecture de lignes au clavier et affichage des! mmes lignes sans les blancs. Arrt par Ctrl_D!-----------------------------------------------do

    doread(*,"(a)",advance="no",eor=1,end=2) cif(c /= " ")write(*,"(a)",advance="no") c

    end do1 write(*,"(a)",advance="yes")

    end do!-----------------------------------------------

    2 print *,"Fin de la saisie."

    Enter

    a b c d \n

    e f \n

    ^D

    a b c d \n

    e f \n

    associ

    au

    clavier

    buffer

    de

    sortie

    buffer

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 231 / 317

    Nouveauts sur les E/S Paramtres IOSTAT et IOMSG de linstruction READ

    Paramtres IOSTAT et IOMSG de linstruction READ

    Le module intrinsque ISO_FORTRAN_ENV introduit par le standard 2003 dfinit deuxfonctions is_iostat_end, is_iostat_eor permettant de grer les vnements fin defichier et fin denregistrement respectivement.De plus, un nouveau mot-cl IOMSG prcis au niveau de linstruction READ permet derfrencer une chane de caractres laquelle sera valorise en cas derreur au textecorrespondant au traitement de laction standard du compilateur.

    Rcriture de lexemple prcdent

    character(len=1) :: cinteger :: ios!-----------------------------------------------! Lecture de lignes au clavier et affichage des! mmes lignes sans les blancs. Arrt par Ctrl_D!-----------------------------------------------do

    read(*,"(a)",advance="no",iostat=ios) cif ( is_iostat_end(ios) ) exitif ( is_iostat_eor(ios) ) then

    write(*,"(a)",advance="yes")cycle

    end ifif(c /= " ")write(*,"(a)",advance="no") c

    end doprint *,"Fin de la saisie."

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 232 / 317

  • Nouveauts sur les E/S Paramtres IOSTAT et IOMSG de linstruction READ

    Paramtres IOSTAT et IOMSG de linstruction READ

    Autre exemple

    PROGRAM saisie_clavierimplicit noneINTEGER :: dateINTEGER :: iosCHARACTER(len =256) :: errmess

    doprint *,"Saisie dune date :"read( *, (i4), IOSTAT=ios , IOMSG=errmess ) dateif ( is_iostat_end(ios) ) exitif ( ios > 0 ) then

    print *, trim(errmess)print *,"Saisie invalide. Veuillez recommencer."

    elseprint (i4), date

    end ifend doprint *, "Arrt de la saisie."

    END PROGRAM saisie_clavier

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 233 / 317

    Nouveauts sur les E/S Instruction NAMELIST

    Instruction NAMELIST

    Exemple

    integer :: nreal ,dimension (2) :: xcharacter(len =5) :: textnamelist /TRUC/ n,x,text...........

    read(*, nml=TRUC)x=x+n*2open(unit=6,delim="apostrophe")write(6, nml=TRUC)

    Exemples de jeux de donnes lire :

    &TRUC n=3 x=5.,0. text="abcde" /&TRUC x=2*0.0 text="abcde" n=3 /&TRUC text="QWERT" x=1.0 /

    Lcriture correspondant au premier jeu de donnes donnerait :&TRUC n=3, x=11.,6., text=abcde /

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 234 / 317

  • Nouveauts sur les E/S Instruction NAMELIST

    Norme 95 : possibilit de commenter via le caractre ! des enregistrements en entredune NAMELIST :

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

    Note : en Fortran 77, la fin des donnes tait en gnral repre par &END ou $END aulieu de / et les enregistrements devaient commencer par un blanc. La relecture dedonnes codes avec lancien format est soit automatiquement compatible (ex : ifortdINTEL), soit assure via :

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 235 / 317

    Nouveauts sur les E/S Spcification de format minimum

    Spcification de format

    Norme 95 : afin de permettre lcriture formate de variables sans avoir se proccuperde la largeur du champ rcepteur, il est possible de spcifier une longueur nulle avec lesformats I, F, B, O et Z :

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

    On vite ainsi limpression dastrisques bien connue des programmeurs Fortran dans lecas dun dbordement de la zone rceptrice.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 236 / 317

  • Nouvelles fonctions intrinsques

    1 Introduction

    2 Gnralits

    3 Types drivs

    4 Programmation structure

    5 Extensions tableaux

    6 Gestion mmoire

    7 Pointeurs

    8 Interface de procdures et modules

    9 Interface gnrique

    10 Surcharge ou cration doprateurs

    11 Contrle de visibilit, concept dencapsulation et gestion de zones dynamiques

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 237 / 317

    Nouvelles fonctions intrinsques

    12 Procdures rcursives

    13 Nouveauts sur les E/S

    14 Nouvelles fonctions intrinsquesAccs lenvironnement, ...Prcision/codage numrique : tiny/huge, sign, nearest, spacing, ...Mesure de temps, date, nombres alatoiresTransformation (transfer)Conversion entiers/caractres (char, ichar, ...)Comparaison de chanes (lge, lgt, lle, llt)Manipulation de chanes (adjustl, index, ...)Oprations sur les bits (iand, ior, ishft, ...)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 238 / 317

  • Nouvelles fonctions intrinsques Accs lenvironnement, ...

    Procdures daccs lenvironnement

    Il est dsormais possible daccder de faon portable aux arguments de la ligne decommande et aux variables denvironnement laides de procdures.

    GET_COMMAND( [command] [,length] [,status] )

    command est une chane de caractres dans laquelle sera stock le nom de lacommande (y compris les arguments sils existent) qui a servi lancer lexcutable.Elle sera valorise avec des blancs si la rcupration est impossible ;

    length est un entier qui sera valoris la longueur de la chane de caractresci-dessus. Si impossibilit, 0 sera retourne ;

    status est un entier qui sert de code retour. Sa valeur sera : 0 si lexcution sest bien droule ; -1 si largument command a t prcise avec une taille infrieure la longueur de la

    commande ; > 0 si lexcution sest termine en erreur.

    Exempleprogram p

    implicit nonecharacter(len=:), allocatable :: commandeinteger longcall GET_COMMAND( LENGTH=long )allocate( character(len=long) :: commande )call GET_COMMAND( COMMAND=commande )print *, "Commande lance ==> ", commandedeallocate( commande )

    end program p

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 239 / 317

    Nouvelles fonctions intrinsques Accs lenvironnement, ...

    GET_COMMAND_ARGUMENT( number [,value] [,length] [,status] )

    number est un entier qui est fourni en entre. Il indique le numro de largumentdsir parmi ceux spcifis lors du lancement de lexcutable. La valeur 0 faitrfrence au nom de lexcutable et la fonction COMMAND_ARGUMENT_COUNT retournele nombre darguments qui suivent ;

    value est une chane de caractres dans laquelle sera retourne largument dsignci-dessus. Une chane blancs sera renvoye si la valorisation est impossible ;

    length est un entier qui sera valoris la longueur de la chane de caractresci-dessus. Si impossibilit, 0 sera retourne ;

    status est un entier qui sert de code retour qui est valoris de la mme faon quepour la procdure GET_COMMAND.

    Exemple

    program pimplicit nonecharacter(len=:), allocatable :: arginteger long , ido i=0, COMMAND_ARGUMENT_COUNT ()

    call GET_COMMAND_ARGUMENT( NUMBER=i, LENGTH=long )allocate( character(len=long) :: arg )call GET_COMMAND_ARGUMENT( NUMBER=i, VALUE=arg )print *,"Argument de rang ", i, " ==> ", argdeallocate( arg )

    end doend program p

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 240 / 317

  • Nouvelles fonctions intrinsques Accs lenvironnement, ...

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

    name est une chane de caractres valorise au nom de la variable denvironnementdont on dsire le contenu ;

    value est une chane de caractres dans laquelle sera retourne le contenu de lavariable denvironnement fournie ci-dessus. Une chane blancs sera renvoye dansles cas suivant :

    la variable denvironnement indique nexiste pas ; la variable denvironnement existe mais son contenu est vide ; la notion de variable denvironnement nexiste pas sur la plateforme utilise.

    length est un entier qui sera valoris la longueur de la valeur de la variabledenvironnement fournie si celle-ci existe et a un contenu dfini. Sinon 0 sera lavaleur retourne ;

    status est un entier qui sert de code retour qui est valoris de faon suivante : si la variable denvironnement existe avec un contenu vide ou bien admet une valeur

    retourne avec succs,0 sera la valeur retourne ;

    si la variable denvironnement existe et admet un contenu dont la taille est suprieure celle de la chane de caractres fournie via le paramtre value, -1 sera retourne ;

    ce code de retour est valoris 1 si la variable denvironnement nexiste pas et 2 si ilny a pas de notion de variable denvironnement sur la plateforme utilise.

    trim_name est un logique. Sil a pour valeur .FALSE. alors les caractres blancssitus la fin du paramtre name seront considrs comme significatifs. Ils serontignors dans les autres cas.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 241 / 317

    Nouvelles fonctions intrinsques Accs lenvironnement, ...

    Exemple

    program pimplicit nonecharacter(len=:), allocatable :: pathinteger long

    call GET_ENVIRONMENT_VARIABLE( NAME="PATH", LENGTH=long )allocate( character(len=long) :: path )call GET_ENVIRONMENT_VARIABLE( NAME="PATH", VALUE=path )print *, "PATH=", pathdeallocate( path )

    end program p

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 242 / 317

  • Nouvelles fonctions intrinsques Accs lenvironnement, ...

    Les deux procdures suivantes permettent de rcuprer des informations propos ducompilateur qui a permis la construction de lexcutable :

    COMPILER_VERSION : fonction retournant la version du compilateur utilis ; COMPILER_OPTIONS : fonction retournant la liste des options qui ont t fournies lorsde la compilation.

    Exemple

    program optionsuse ISO_FORTRAN_ENVcharacter(len =10) arglogical mode_verbose

    mode_verbose = .false.do i=1, command_argument_count ()

    call get_command_argument(i,arg)if ( arg .eq. "-v" ) then

    mode_verbose = .true.exit

    end ifend doif ( mode_verbose ) then

    print (a,/,a), "Version du compilateur utilis :", &COMPILER_VERSION ()

    print (a,/,a), "Options transmises au compilateur :", &COMPILER_OPTIONS ()

    end ifend program options

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 243 / 317

    Nouvelles fonctions intrinsques Prcision/codage numrique : tiny/huge, sign, nearest, spacing, ...

    Prcision et codage numrique

    SPACING(X)NEAREST(X, +1.)NEAREST(X, 1.)

    X

    10 1010 rr r r

    huge

    ZeroOverflow Overflowtiny +tiny

    10

    Underflow +huge

    R

    TINY(x) plus petite valeur relle reprsentable dans le sous-type de x (limite delunderflow).

    HUGE(x) plus grande valeur relle ou entire reprsentable dans le sous-type dex (limite de loverflow).

    NEAREST(x, s) valeur relle reprsentable la plus proche ( droite si s>0. ou gauchesi s

  • Nouvelles fonctions intrinsques Prcision/codage numrique : tiny/huge, sign, nearest, spacing, ...

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

    Note : le zro rel classique (+0.) a une reprsentation binaire totalement nulle alorsque le zro ngatif (-0.) a son bit de signe positionn 1 (80000000 en hexa.). Seule lafonction SIGN (au niveau du 2e argument) fait la distinction entre ces deux zros. Cettedistinction peut aussi tre faite via une impression en format libre. La valeur -0. estreprsentable sur NEC SX8 et IBM SP6.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 245 / 317

    Nouvelles fonctions intrinsques Mesure de temps, date, nombres alatoires

    Mesure de temps, nombres alatoires

    CPU_TIME(time) (disponible depuis la norme 95) sous-progr. retournant dans le rel timele temps CPU en secondes (ou rel < 0 si indisponible). Par diffrence entredeux appels, il permet dvaluer la consommation CPU dune section de code.

    DATE_AND_TIME(date,time,zone,values) sous-programme retournant dans les variablescaractre date et time, la date et lheure en temps dhorloge murale.Lcart par rapport au temps universel est retourn optionnellement danszone. Toutes ces informations sont aussi stockes sous forme dentiers dansle vecteur values.

    SYSTEM_CLOCK(count,count_rate,count_max) sous-programme retournant dans desvariables entires la valeur du compteur de priodes dhorloge (count), lenombre de priodes/sec. (count_rate) et la valeur maximale de cecompteur (count_max) ; ne permet pas dvaluer le temps CPU consommpar une portion de programme.

    RANDOM_NUMBER(harvest) sous-progr. retournant un/plusieurs nombres pseudo-alatoirescompris entre 0. et 1. dans un scalaire/tableau rel pass en argument(harvest).

    RANDOM_SEED(size,put,get) sous-programme permettant de r-initialiser une srie denombres alatoires. Tous les arguments sont optionnels. En leur absence legerme dinitialisation dpend du constructeur. Voir exemples ci-aprs...

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 246 / 317

  • Nouvelles fonctions intrinsques Mesure de temps, date, nombres alatoires

    Exemple

    real ,dimension (2048 ,4) :: tabcall random_number(tab) ! 1re srie. . . .

    call random_number(tab) ! 2me srie diffrente. . . .

    Gnration de deux sries identiques de nombres alatoires dans un tableau tab ensauvegardant (GET) puis rinjectant (PUT) le mme germe. La taille du vecteurlast_seed de sauvegarde du germe est rcupre via largument de sortie SIZE :Exemple

    integer :: ninteger ,allocatable ,dimension (:) :: last_seedreal ,dimension (2048 ,4) :: tabcall random_seed(SIZE=n)allocate(last_seed(n)) ; call random_seed(GET=last_seed)call random_number(tab) ! 1re srie. . . .

    call random_seed(PUT=last_seed)call random_number(tab) ! 2me srie identiquedeallocate(last_seed )

    Attention : il est recommand de grer le germe dinitialisation uniquement via lesous-programme RANDOM_SEED.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 247 / 317

    Nouvelles fonctions intrinsques Mesure de temps, date, nombres alatoires

    valuation du temps CPU et du temps dhorloge (elapsed time)

    INTEGER :: &cpt_init ,& ! Val. init. compteur priodes horlogecpt_fin , & ! Val. finale compteur priodes horlogecpt_max , & ! Valeur maximale du compteur dhorlogefreq , & ! Nb. de priodes dhorloge par secondecpt ! Nb. de priodes dhorloge du code

    REAL :: temps_elapsed , t1 , t2 , t_cpu. . .! Initialisations! ---------------CALL SYSTEM_CLOCK(COUNT_RATE=freq , COUNT_MAX=cpt_max). . .CALL SYSTEM_CLOCK(COUNT=cpt_init)CALL CPU_TIME(TIME=t1). . .!>>>. . .CALL CPU_TIME(TIME=t2)CALL SYSTEM_CLOCK(COUNT=cpt_fin)!cpt = cpt_fin - cpt_initIF (cpt_fin < cpt_init) cpt = cpt + cpt_maxtemps_elapsed = REAL(cpt) / freqt_cpu = t2 - t1!print *, "Temps elapsed = ", temps_elapsed , " sec."print *, "Temps CPU = ", t_cpu , " sec.". . .

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 248 / 317

  • Nouvelles fonctions intrinsques Mesure de temps, date, nombres alatoires

    Sortie de la date et de lheure courante via la fonction intrinsque DATE_AND_TIME

    program dateimplicit noneinteger :: ninteger , dimension (8) :: valeurs!call DATE_AND_TIME(VALUES=valeurs)print *print "(49a)", ("-", n=1,49)print "(a,2(i2.2,a),i4,a,3(i2.2,a),a)", &

    "| Test date_and_time ==> ", &valeurs (3), "/", &valeurs (2), "/", &valeurs (1), " - ", &valeurs (5), "H", &valeurs (6), "M", &valeurs (7), "S", " |"

    print "(49a)", ("-", n=1,49)end program date

    Sortie correspondante :-------------------------------------------------| Test date_and_time ==> 14/12/2011 - 10H13M50S |-------------------------------------------------

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 249 / 317

    Nouvelles fonctions intrinsques Transformation (transfer)

    Transformation

    TRANSFER(source, mold [,size])

    scalaire ou vecteur avec reprsentation physique identique celle de source, maisinterprte avec le type de mold.

    Si size absent, retourne un vecteur si mold est de rang 1 (sa taille est le pluspetit nombre tel que sa reprsentation physique mmoire contienne celle de source),sinon un scalaire,

    Si size prsent, retourne un vecteur de taille size.

    Exemple

    TRANSFER( 1082130432, 1.0 ) 4.0 (sur machine IEEE)TRANSFER( (/ 1.,2.,3.,4. /), (/ (0.,0.) /) ) (/ (1.,2.),(3.,4.) /)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 250 / 317

  • Nouvelles fonctions intrinsques Transformation (transfer)

    Exemple

    integer(kind=8), dimension (4) :: tamponcharacter(len =8) :: chreal(kind=8), dimension (3) :: ych = TRANSFER( tampon (1) , "abababab" )!y(:) = TRANSFER( tampon (2:4) , 1.0_8 , 3 )y(:) = TRANSFER( tampon (2:4) , y(:) )

    remplace la version Fortran 77 classique avec EQUIVALENCE 1 :

    integer *8 tampon (4)character *8 str ,chreal*8 x(3),y(3)EQUIVALENCE (tampon (1),str) , (tampon (2),x)ch = stry(:) = x(:)

    1. lEQUIVALENCE fait partie de la norme Fortran 95 et nest pas obsolte. Par contre, lEQUIVALENCE entreun entier (tampon(1)) et une variable caractre (str) est une extension la norme !

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 251 / 317

    Nouvelles fonctions intrinsques Transformation (transfer)

    Utilisation de la fonction TRANSFER pour passer une chane C en vitant la transmissionautomatique de sa longueur.

    integer ,dimension (1) :: itab=0character(len =10) :: chain="0123456789"call sub( transfer(chain//achar (0),itab) )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 252 / 317

  • Nouvelles fonctions intrinsques Conversion entiers/caractres (char, ichar, ...)

    Conversions entiers/caractres

    CHAR(i,[kind]) iime caractre de la table standard (ASCII/EBCDIC) si kind absent, sinon de latable correspondant kind (constructeur dpendant).

    ACHAR(i) idem CHAR avec table ASCII.

    ICHAR(c,[kind]) rang (entier) du caractre c dans la table associe la valeur du mot-cl kind(ASCII/EBCDIC en gnral).

    IACHAR(c)idem ICHAR dans la table ASCII.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 253 / 317

    Nouvelles fonctions intrinsques Comparaison de chanes (lge, lgt, lle, llt)

    Comparaison de chanes

    LGE(string_a, string_b) VRAI si string_a suprieure ou = string_b

    (Lexically Greater or Equal) ; LGT(string_a, string_b) VRAI si string_a suprieure string_b

    (Lexically Greater Than) ; LLE(string_a, string_b) VRAI si string_a infrieure ou = string_b

    (Lexically Less or Equal) ; LLT(string_a, string_b) VRAI si string_a infrieure string_b

    (Lexically Less Than).Remarques

    La comparaison des chanes seffectue caractre par caractre partir de la gaucheen fonction de leur rang dans la table ASCII ;

    En cas dingalit de longueur, la chane la plus courte est complte blanc sur sadroite ;

    Ces quatre fonctions faisaient dj partie de la norme 77 ; Les oprateurs >=, >,

  • Nouvelles fonctions intrinsques Manipulation de chanes (adjustl, index, ...)

    Manipulation de chanes

    ADJUSTL(string) dbarrasse string de ses blancs de tte (cadrage gauche) et complte droitepar des blancs.

    ADJUSTR(string) idem ADJUSTL mais droite. INDEX(string, substring [,back]) numro (entier) du premier caractre de string o apparat la sous-chanesubstring (sinon 0). Si la variable logique back est vraie : recherche en sens inverse.

    LEN_TRIM(string) longueur (entier) de la chane dbarrasse de ses blancs de fin.

    SCAN(string, set [,back]) numro (entier) du premier caractre de string figurant dans set ou 0 sinon. Sila variable logique back est vraie : recherche en sens inverse.

    VERIFY(string, set [,back]) numro (entier) du premier caractre de string ne figurant pas dans set, ou 0 sitous les caractres de string figurent dans set. Si la variable logique back estvraie : recherche en sens inverse.

    REPEAT(string, ncopies) chane obtenue en concatnant ncopies copies de string.

    TRIM(string) dbarrasse string de ses blancs de fin.Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 255 / 317

    Nouvelles fonctions intrinsques Oprations sur les bits (iand, ior, ishft, ...)

    Oprations sur les bits

    IAND(i,j) fonction retournant un entier de mme type que irsultant de la combinaison bit bit de i et j par unET logique.

    IEOR(i,j) fonction retournant un entier de mme type que irsultant de la combinaison bit bit de i et j par unOU exclusif logique.

    IOR(i,j) fonction retournant un entier de mme type que irsultant de la combinaison bit bit de i et j par unOU inclusif logique.

    ISHFT(i,shift) fonction retournant un entier de mme type que irsultant du dcalage de shift bits appliqu i.Dcalage vers la gauche ou vers la droite suivant quelentier shift est positif ou ngatif. Les bits sortant sontperdus et le remplissage se fait par des zros.

    ISHFTC(i,shift[,size]) fonction retournant un entier de mme type que irsultant dun dcalage circulaire de shift positionsappliqu aux size bits de droite de i. Dcalage vers lagauche ou vers la droite suivant que lentier shift estpositif ou ngatif.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 256 / 317

  • Nouvelles fonctions intrinsques Oprations sur les bits (iand, ior, ishft, ...)

    IBCLR(i,pos) fonction retournant un entier identique i avecle posime bit mis zro ;

    IBSET(i,pos) fonction retournant un entier identique i avecle posime bit mis 1 ;

    NOT(i) fonction retournant un entier de mme type quei, ses bits correspondant au complmentlogique de ceux de i ;

    IBITS(i,pos,len) fonction stockant dans un entier de mme typeque i les len bits de i partir de la positionpos. Ces bits sont cadrs droite et complts gauche par des zros ;

    MVBITS(from,frompos,len,to,topos) sous-programme copiant une squence de bitsdepuis une variable entire (from) vers une autre(to).

    Remarques

    1 ces fonctions ont t tendues pour sappliquer aussi des tableaux dentiers ;2 Norme 95 : le sous-programme MVBITS est pure et elemental .

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 257 / 317

    Annexe A : paramtre KIND et prcision des nombres

    15 Annexe A : paramtre KIND et prcision des nombresSur IBM/SP6Sur NEC/SX8

    16 Annexe B : exercices

    17 Annexe C : apports de la norme 95

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 258 / 317

  • Annexe A : paramtre KIND et prcision des nombres Sur IBM/SP6

    paramtre KIND sur IBM/SP6

    Type Variante Nb octets tendue PrcisionEntier 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 /////////

    Rel kind=4 4 1.2 1038 | r | 3.4 1038 6 chiffreskind=8 8 2.2 10308 | r | 1.8 10308 15 chiffreskind=16 16 2.2 10308 | r | 1.8 10308 31 chiffres

    Complexe kind=4 (4,4) 1.2 1038 | r | 3.4 1038 6 chiffreskind=8 (8,8) 2.2 10308 | r | 1.8 10308 15 chiffreskind=16 (16,16) 2.2 10308 | 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 /////////

    Caractre kind=1 1 jeu ASCII /////////

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 259 / 317

    Annexe A : paramtre KIND et prcision des nombres Sur NEC/SX8

    paramtre KIND sur NEC/SX8

    Type Variante Nb octets tendue PrcisionEntier kind=2 2 215 i 215 1 /////////

    kind=4 4 231 i 231 1 /////////kind=8 8 263 i 263 1 /////////

    Rel kind=4 4 1.2 1038 | r | 3.4 1038 6 chiffreskind=8 8 2.2 10308 | r | 1.8 10308 15 chiffreskind=16 16 2.2 10308 | r | 1.8 10308 31 chiffres

    Complexe kind=4 (4,4) 1.2 1038 | r | 3.4 1038 6 chiffreskind=8 (8,8) 2.2 10308 | r | 1.8 10308 15 chiffreskind=16 (16,16) 2.2 10308 | 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 /////////

    Caractre kind=1 1 jeu caractres ASCII /////////kind=2 2 jeu caractres Japonais /////////

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 260 / 317

  • Annexe B : exercices

    15 Annexe A : paramtre KIND et prcision des nombres

    16 Annexe B : exercicesnoncsExercices : corrigs

    17 Annexe C : apports de la norme 95

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 261 / 317

    Annexe B : exercices noncs

    Exercice 1

    Compiler et excuter le programme contenu dans les fichiers exo1.f90, mod1_exo1.f90 et mod2_exo1.f90 :

    program exo1use mod2implicit nonereal :: sommeinteger :: itab =(/ (i*10,i=1,5) /)print *, tabcall sp1s(somme)print *,sommecall sp2s(somme)print *,somme

    end program exo1

    module mod1real ,dimension (5) :: tab

    end module mod1

    module mod2use mod1

    containssubroutine sp1s(som)

    implicit nonereal :: sominteger :: Isom =0.do i=1,5

    som=som+tab(i)enddo

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

    implicit nonereal :: xx=-x

    end subroutine sp2send module mod2

    Recommencez en plaant les modules dans un rpertoire diffrent de celui o se trouve le programme principal.Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 262 / 317

  • Annexe B : exercices noncs

    Exercice 2

    crire un programme permettant de valoriser la matrice identit de n lignes et n colonnes en vitant les traitements lmentairesvia les boucles DO pour utiliser autant que possible les fonctions intrinsques de manipulation de tableaux. Imprimer la matriceobtenue ligne par ligne et explorer plusieurs solutions mettant en uvre les fonctions RESHAPE, UNPACK, CSHIFT ainsi que le blocWHERE.

    Exercice 3

    Compltez le programme suivant en rcrivant les boucles imbriques laide dune expression tableaux :program exo3

    implicit noneinteger , parameter :: nx=100, ny=200, nz=5real , dimension(nx,ny ,nz) :: tab1 , tab2real :: vec1(nx), vec2(ny)integer :: i, j, k

    call random_number(vec1); call random_number(vec2)! Calculs scalairesDO k=1,nz

    DO j=1,nyDO i=1,nx

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

    ENDDOENDDO

    ! Boucles prcdentes rcrites laide dune expression tableaux :! ...! ...block

    integer , parameter :: k = 3

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

    elseprint *, "tab1/=tab2"

    end ifend block

    end program exo3

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 263 / 317

    Annexe B : exercices noncs

    Exercice 4

    crire un programme permettant de valoriser une matrice de n lignes et m colonnes (n et m ntant connus quau moment delexcution) de la faon suivante :

    1 les lignes de rang pair seront constitues de lentier 1,

    2 les lignes de rang impair seront constitues des entiers successifs 1, 2, 3, ....

    Par exemple :

    (1 2 3 41 1 1 15 6 7 8

    )Imprimer la matrice obtenue ligne par ligne afin de vrifier son contenu.

    Exercice 5

    Allouer une matrice relle NxN (N multiple de 4) ; linitialiser avec real(i) pour i variant de 1 N*N. Transformer cette matriceen rordonnant les lignes et les colonnes de la faon 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 dernires colonnes/lignes devant les 2 premires colonnes/lignes et garder ces 4 colonnes/lignesensembles. Ritrer ce processus en repartant des 2 dernires colonnes/lignes sans dplacer celles dej transformes et ainsi desuite... Imprimer la matrice avant et aprs transformation et vrifier que la trace de la matrice est inchange.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 264 / 317

  • Annexe B : exercices noncs

    Exercice 6

    crire un programme permettant de reconnatre si une chane est un palindrome. Lire cette chane dans une variable de typecharacter(len=long) qui sera ensuite transfre dans un tableau (vecteur) de type character(len=1) pour faciliter samanipulation via les fonctions intrinsques tableaux. crire ce programme de faon modulaire et volutive ; dans un premiertemps, se contenter de lire la chane (simple mot) au clavier et dans un deuxime, ajouter la possibilit de lire un fichier (cf.fichier palindrome) contenant des phrases (suite de mots spars par des blancs quil faudra supprimer phase de compression).

    Exercice 7

    Complter le programme contenu dans le fichier exo7.f90 jusqu ce quil sexcute correctement : les 2 matrices imprimesdevront tre identiques.

    program exo7implicit noneinteger , parameter :: n=5,m=6integer(kind =2) :: iinteger , 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,:)enddocall sp(a)

    end program exo7subroutine sp(a)

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

    print *,a(i,:)enddo

    end subroutine sp

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 265 / 317

    Annexe B : exercices noncs

    Exercice 8

    crire un programme permettant limpression des n premires lignes du triangle de Pascal avec allocation dynamique du triangleconsidr comme un vecteur de lignes de longueur variable.

    Par exemple :

    11 11 2 11 3 3 11 4 6 4 1

    Exercice 9

    Dveloppez le module surcharge afin que le source suivant produise la sortie qui suit :

    program exo9use surcharge

    integer i, jlogical b1, b2

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

    if ( b1 == b2 ) print *, "b1 == b2"if ( b1 /= b2 ) print *, "b1 /= b2"

    end program exo9

    Sortie :

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 266 / 317

  • Annexe B : exercices noncs

    Exercice 10

    Cet exercice reprend le module matrix des chapitres 10 et 11 (cf. page 213) du support de cours. Il est stock (avec unprogramme principal dutilisation complet) dans le fichier exo10.f90.

    Compltez le module matrix en dfinissant un oprateur .vp. permettant le calcul des valeurs propres dun objet de typeOBJ_MAT. Utilisez par exemple le sous-programme EVLRG (calculant les valeurs propres dune matrice relle dordre N) de labibliothque IMSL dont la squence dappel est :

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

    - N : nombre de lignes de A (entre)- A : matrice relle dordre N (entre)- LDA : "Leading Dimension of A" (N ici) (entre)- EVAL : vecteur contenant les N valeurs (sortie)

    propres complexes

    En entre :le programme principal lit (en format libre et avec le paramtre ADVANCE="NO") un fichier exo10.data avec un enregistrementcontenant :

    un entier reprsentant lordre N de la matrice, N*N valeurs relles reprsentant les lments de la matrice traiter.

    Un exemple dun tel fichier (avec une matrice dordre N=4) est contenu dans exo10.data. Les valeurs propres attendues sont lessuivantes : (4.,0.), (3.,0.), (2.,0.), (1.,0.).

    Notes :

    deux mthodes ont dj t ajoutes 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 limpression des valeurs propres.

    consultez le README du rpertoire lapack.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 267 / 317

    Annexe B : exercices noncs

    Exercice 11

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

    program exo11use musictype(musicien) :: mus_mort_le_plus_jeunecall initcall tri(critere="nom")call tri(critere="annee")mus_mort_le_plus_jeune = .MortLePlusJeune.tab_musprint *print *,"Le musicien mort le plus jeune est : ", nom(mus_mort_le_plus_jeune)

    end program exo11

    Dans le module music crer, dfinir : 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 annes de naissance et de mort : ditez-le au pralable afin de connatre son formatage) afin de valoriser le tableautab_mus et limprimer,

    le sous-programme tri qui trie et imprime la liste des musiciens. Passer en argument le critre de tri sous forme dunechane de caractres et effectuer ce tri par lintermdiaire dun tableau de pointeurs,

    de sorte que lexcution de ce programme produise les rsultats suivants :

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 268 / 317

  • Annexe B : exercices noncs

    ---- Liste des musiciens ----

    Johann Sebastian Bach 1685 1750Georg Friedrich Haendel 1685 1759Wolfgang Amadeus Mozart 1756 1791Giuseppe Verdi 1813 1901Richard Wagner 1813 1883Ludwig van Beethoven 1770 1827

    . . . . . . . . . . .

    . . . . . . . . . . .Igor Stravinski 1882 1971Piotr Ilyitch Tchaikovski 1840 1893Antonio Vivaldi 1678 1741Carl Maria von Weber 1786 1826Giacomo Puccini 1858 1924Claude Debussy 1862 1918Joseph Haydn 1732 1809Gustav Mahler 1860 1911

    ---- Liste alphabtique des musiciens ----

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

    . . . . . . . . . . .

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

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 269 / 317

    Annexe B : exercices noncs

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

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

    . . . . . . . . . . .

    . . . . . . . . . . .Maurice Ravel 1875 1937Igor Stravinski 1882 1971

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

    Exercice 12

    Mme exercice que prcdemment mais avec utilisation dune liste chane simple ou double en partant du programme principalsuivant contenu dans le fichier exo12.f90 :

    program exo12use musictype(musicien) :: mus_mort_le_plus_jeunecall initcall tri(critere="nom")call tri(critere="annee")mus_mort_le_plus_jeune = .MortLePlusJeune.debutprint *print *,"Le musicien mort le plus jeune est : ", nom(mus_mort_le_plus_jeune)

    end program exo12

    Remarque : debut correspond au pointeur de dbut de liste.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 270 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 1 laide du compilateur dINTEL (lutilitaire "makedepf90" permet de gnrer les

    dpendances)

    $ ifort -c mod1_exo1.f90$ ifort -c mod2_exo1.f90$ ifort exo1.f90 mod1_exo1.o mod2_exo1.o -o exo1$ ./exo1

    Remarque : si les modules sont situs dans un rpertoire rep1 diffrent de celui (rep2) dexo1, utiliser loption -I :

    $ cd $HOME/rep1$ ifort -c mod1_exo1.f90 mod2_exo1.f90$ cd ../ rep2$ ifort exo1.f90 -I../ rep1 ../ rep1/mod*.o -o exo1$ ./exo1

    Exemple laide dun fichier "makefile" :

    $ cat makefileSRCS= mod1_exo1.f90 mod2_exo1.f90 exo1.f90OBJS= $(SRCS:f90=o)FC=ifortFFLAGS=.SUFFIXES: .f90

    all: exo1

    .f90.o:$(FC) $(FFLAGS) -c $> makefile ; make$ makedepf90 mod1_exo1.f90 mod2_exo1.f90 exo1.f90 -o exo1 > makefile ; make

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 271 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 2

    program exo2implicit noneinteger , parameter :: n = 10real , dimension(n,n) :: mat_identcharacter(len=8) :: fmt = "(00f3.0)"

    write(fmt(2:3), "(i2)") n ! Format dimpression!============== > Premire solution :call sol_unpackcall imp!============== > Deuxime solution :call sol_reshapecall imp!============== > Troisime solution :call sol_cshiftcall imp

    containssubroutine sol_unpack

    logical , dimension(n,n) :: maskreal , dimension(n) :: diag = 1.integer :: i, j

    mask = reshape( source =[ ((i==j, i=1,n), j=1,n) ], shape=shape(mask) )mat_ident = unpack(diag , mask , 0.)

    end subroutine sol_unpack

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 272 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 2 (suite)

    subroutine sol_reshapereal , dimension(n*n) :: vect = 0.

    vect (1:n*n:n+1) = 1.mat_ident = reshape( vect , shape=shape(mat_ident) )

    end subroutine sol_reshape!subroutine sol_cshift

    integer i

    mat_ident (:,:) = 0.mat_ident (:,1) = 1.mat_ident (:,:) = cshift( array=mat_ident , &

    shift =(/ (-i,i=0,n-1) /), &dim=2 )

    end subroutine sol_cshift!subroutine imp

    integer i

    do i=1,n ! Impression matrice identitprint fmt, mat_ident(i,:)

    end doprint *

    end subroutine impend program exo2

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 273 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 3

    program exo3implicit noneinteger , parameter :: nx=100, ny=200, nz=5real , dimension(nx,ny ,nz) :: tab1 , tab2real , dimension(nx) :: vec1real , dimension(ny) :: vec2integer i, j, k

    call random_number(vec1)call random_number(vec2)! Calculs scalairesDO k=1,nz

    DO j=1,nyDO i=1,nx

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

    ENDDOENDDO! Boucles prcdentes rcrites :tab2 (:,:,:) = SPREAD(source=SPREAD(source=sqrt(vec1 (:)),dim=2,ncopies=ny)* &

    SPREAD(source=exp(vec2 (:)) ,dim=1,ncopies=nx), &dim=3,ncopies=nz)

    blockinteger , parameter :: k = 3if ( maxval(abs(tab1 -tab2)) < minval(k*spacing(tab1)) ) then

    print *, "tab1==tab2"else

    print *, "tab1/=tab2"end if

    end blockend program exo3

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 274 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 4

    program exo4implicit none! On dcide que les entiers n,m sont < 100integer , parameter :: p = selected_int_kind (2)integer(kind=p) :: n,minteger :: iinteger , dimension (:,:), allocatable :: matcharacter(len=6) :: fmt = "( I6)"!print *,"Nombre de lignes :" ; read (*,*)nprint *,"Nombre de colonnes :"; read (*,*)mwrite( fmt(2:3) , (i2) ) mallocate(mat(n,m))! Remplissage des lignes paires avec lentier 1mat (2:n:2,:) = 1! Remplissage lignes impaires avec les entiers 1,2,...mat (1:n:2,:) = reshape( source =(/ (i,i=1,size(mat (1:n:2 ,:))) /), &

    shape=shape( mat (1:n:2,:) ), &order =(/ 2,1 /) )

    print fmt , ((mat(i,j),j=1,m),i=1,n)deallocate(mat)

    end program exo4

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 275 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 5

    program exo5implicit nonereal , dimension (:,:), allocatable :: Alogical , dimension (:,:), allocatable :: minteger :: N, i, jcharacter(len=8) :: fmt = "( F5.0)"

    !------- Allocation/initialisation de A --------------print *, "N (multiple de 4 < 32) ?" ; read *, Nallocate(A(N,N), m(N,N))write( fmt(2:3) , (i2) ) NA = reshape(source =[ (real(i), i=1,N*N) ], shape=shape(A), order=[ 2,1 ])m = reshape(source =[ ((i==j,i=1,N),j=1,N) ], shape=shape(m))call imp( "Matrice transformer :" )!------------- Transformation des lignes -------------do i=1,N,4

    A(:,i:N) = cshift(array=A(:,i:N), shift=-2, dim =2)end do!------------- Transformation des colonnes -----------do i=1,N,4

    A(i:N,:) = cshift(array=A(i:N,:), shift=-2, dim =1)end docall imp( "Matrice transforme :" )deallocate(A) ; deallocate(m)contains

    subroutine imp(titre)character(len=*) titre

    print "(/,A,/)", titreprint fmt , ((A(i,j),j=1,N),i=1,N)print *, "trace = ", sum(pack(array=A, mask=m))

    end subroutine impend program exo5

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 276 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6

    program exo6integer , parameter :: long =80character(len=long) :: chaineinteger :: long_util , ios , choixlogical :: entree_validedo

    entree_valide = .true.print *, "1) Entre clavier"print *, "2) Lecture fichier palindrome "read( unit=*, fmt=*, iostat=ios ) choixif(ios > 0) entree_valide = .false.; if(ios < 0) stop "Arrt demand"if(choix /= 1 .and. choix /= 2) entree_valide =.false.if(entree_valide ) exitprint *, "Entre invalide"

    end doif ( choix ==2 ) open( unit=1, file="palindrome", form="formatted", action="read" )do

    select case(choix)case (1)

    print *, "Entrez une chane :" ; read(unit=*, fmt="(a)", iostat=ios) chainecase (2)

    read(unit=1, fmt="(a)", iostat=ios) chaineend selectif(ios > 0) stop "Erreur de lecture"; if(ios < 0) exitlong_util = len_trim( chaine )if( palind( chaine (: long_util) ) ) then

    print *, chaine (: long_util), " est un palindrome"else

    print *, chaine (: long_util), " nest pas un palindrome"endif

    enddoif ( choix == 2 ) close( unit=1 )

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 277 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6 (suite)

    containsfunction palind( chaine )

    logical :: palind !

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6 : version norme 2003

    module exo6_mimplicit noneinteger :: choix

    containssubroutine choix_fichier

    logical :: entree_valideinteger :: ios

    doentree_valide = .true.print *, 1) Entre clavier print *, 2) Lecture fichier "palindrome"print *, Faire CtrD pour quitter read( unit=*, fmt=*, iostat=ios ) choixif ( ios > 0 ) entree_valide = .false.if ( ios < 0 ) stop "Arrt demand"if ( choix /= 1 .and. choix /= 2 ) entree_valide =. false.if ( entree_valide ) exitprint *, "Entre invalide"

    end doif ( choix == 2 ) open( unit=1, file="palindrome", &

    form="formatted", action="read" )end subroutine choix_fichier

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 279 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6 : version norme 2003 (suite)

    subroutine traitement_fichierinteger , parameter :: long =80character(len=long) :: chaineinteger :: ios , long_util

    doselect case( choix )

    case (1)print *, "Entrez une chane :"read( unit=*, fmt=(a), iostat=ios ) chaine

    case (2)read( unit=1, fmt=(a), iostat=ios ) chaine

    end selectif( ios > 0 ) stop "Erreur de lecture"if( ios < 0 ) exit!! Rcup. longueur chane entre (sans blancs de fin).!long_util = len_trim( chaine )

    if( palind( chaine (: long_util) ) ) thenprint *, chaine (: long_util), " est un palindrome"

    elseprint *, chaine (: long_util), " nest pas un palindrome"

    endifenddoif ( choix == 2 ) close( unit=1 )

    end subroutine traitement_fichier

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 280 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6 : version norme 2003 (suite)

    function palind( chaine )! Dclaration argument et retour de fonctionlogical :: palindcharacter(len=*) :: chaine! Dclarations localescharacter(len=1), dimension (:), allocatable :: tab_carinteger :: long_util , i

    ! Copie chane entre dans un tableau de caractres.! Norme 2003 : linstruction qui suit alloue 1 le tableau! ---------- tab_car avec la taille ncessaire afin! de respecter la conformance.tab_car = [ (chaine(i:i), i=1, len(chaine )) ]!! Dans le cas o la chane contient une phrase ,! on supprime les blancs sparant les diffrents mots.!call compression( tab_car )!! Comparaison des lments symtriques par rapport! au milieu de la chane. La fonction all nous sert! comparer le contenu de deux tableaux.!long_util = size( tab_car (:) )palind = all( tab_car (: long_util /2) == &

    tab_car(long_util:long_util -long_util /2+1: -1) )

    1. Attention : avec le compilateur ifort dINTEL il est ncessaire de positionner loption -assume real-loc_lhs pour bnficier de ce mcanisme dallocation/rallocation automatique.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 281 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 6 : version norme 2003 (suite)

    contains

    subroutine compression( tab_car )character(len=1), dimension (:), allocatable :: tab_car ! norme 2003logical , dimension(size(tab_car )) :: m !

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 7

    program exo7! Dans sp largument a est un tableau profil implicite , linterface doit donc! tre explicite , do lajout du bloc interface . Dans ce contexte , seul le profil de! a est transmis , pas les bornes infrieures qui sont considres gales 1.implicit noneinterface

    subroutine sp(a)integer , dimension (:,:) :: a

    end subroutine spend interfaceinteger , parameter :: n=5,m=6integer(kind =2) :: iinteger , dimension (0:n-1,0:m-1) :: a = reshape ((/ (i*100,i=1,n*m) /), shape(a))

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

    print *,a(i,:)enddocall sp(a)

    end program exo7!------------------subroutine sp(a)

    integer , dimension (:,:) :: a ! ou integer, dimension(0:,0:) :: a (bornes inf. 0)integer :: i

    print *print *, "Matrice a dans sp :"print *, "-----------------"print *do i=1,size(a,1) ! do i=0,size(a,1)-1 (si bornes inf. = 0)

    print *,a(i,:)enddo

    end subroutine sp

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 283 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 8 (solution Fortran 2003)

    program exo8implicit nonetype ligne

    integer , dimension (:), allocatable :: p ! la place de pointer : norme 2003end type lignetype(ligne), dimension (:), allocatable :: triangleinteger :: i, n, etatcharacter (11) :: fmt = "(00(i5 ,1x))"

    dowrite(*,advance="no",fmt="(Ordre du triangle ? :)")read(*, *, iostat=etat)nif (etat /= 0 .OR. n > 20) exit ! On limite 20 ligneswrite(fmt(2:3), "(i2)")n ! Construction du format de sortieallocate(triangle(n))do i=1,n

    !--- Pour chaque ligne du triangle , allocation du nombre de colonnes.allocate(triangle(i)%p(i))!-Valorisation des lments extrmes de la ligne courante puis des!-lments intermdiaires au moyen dune expression vectorielle.triangle(i)%p( (/ 1,i /) ) = 1!-Pour i=1 ou i=2 , les oprandes de lexpression suivante sont!-des tableaux de taille nulle : zero-size array triangle(i)%p(2:i-1) = triangle(i-1)%p(2:i-1) + triangle(i-1)%p(1:i-2)print fmt,triangle(i)%p ! Impression de la ligne

    end do!-- Libration du triangle. Les composantes p de!-- chacun des lments du triangle seront libres!-- automatiquement.deallocate(triangle)

    end doend program exo8

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 284 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 9

    module surchargeinterface assignment (=)

    module procedure affect_int_boolend interfaceinterface operator (==)

    module procedure compare_eq_boolend interfaceinterface operator (/=)

    module procedure compare_ne_boolend interface

    containslogical function compare_eq_bool( l1 , l2 )

    logical , intent(in) :: l1 , l2

    if( l1.EQV.l2 ) compare_eq_bool = .true.if( l1.NEQV.l2 ) compare_eq_bool = .false.

    end function compare_eq_bool

    logical function compare_ne_bool( l1 , l2 )logical , intent(in) :: l1 , l2

    if( l1.EQV.l2 ) compare_ne_bool = .false.if( l1.NEQV.l2 ) compare_ne_bool = .true.

    end function compare_ne_bool

    subroutine affect_int_bool( i, l )integer , intent(inout) :: ilogical , intent(in) :: l

    if ( l ) i=1if ( .NOT.l ) i=0

    end subroutine affect_int_boolend module surcharge

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 285 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 10

    module matriximplicit noneinteger :: nb_lignes , nb_colinteger , private :: err

    type OBJ_MATprivateinteger :: n=0, m=0real , dimension (:,:), allocatable :: mat

    end type OBJ_MAT

    private :: add , trans , taille_mat , valorisation , affectprivate :: val_propres!-------------------------------interface operator (+)

    module procedure addend interface!-------------------------------interface operator (.tr.)

    module procedure transend interface!-------------------------------!interface operator (.vp.) !

    module procedure val_propres !end interface !!-------------------------------!interface assignment (=)

    module procedure taille_mat , valorisation , affectend interface

    contains

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 286 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 10 (suite)

    subroutine valorisation(a,t)type(OBJ_MAT), intent(inout) :: areal , dimension (:), intent(in) :: t....

    end subroutine valorisationsubroutine poubelle(a)

    type(OBJ_MAT), intent(inout) :: a....

    end subroutine poubellefunction add(a,b)

    type(OBJ_MAT), intent(in) :: a,btype(OBJ_MAT) :: add....

    end function addfunction trans(a)

    type(OBJ_MAT), intent(in) :: atype(OBJ_MAT) :: trans....

    end function trans!-----------------------------------------------!function val_propres(a) !

    type(OBJ_MAT), intent(in) :: a !complex , dimension(a%n) :: val_propres !if (associated(a%ptr_mat )) then !call evlrg(a%n, a%ptr_mat , a%n, val_propres) !

    else !Stop "Objet non existant" !

    end if !end function val_propres !!-----------------------------------------------!

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 287 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 10 (suite)

    subroutine taille_mat(i,a)integer , intent(out) :: itype(OBJ_MAT), intent(in) :: ai = a%n*a%m

    end subroutine taille_matsubroutine affect(a,b)

    type(OBJ_MAT), intent(inout) :: atype(OBJ_MAT), intent(in) :: b....

    end subroutine affectsubroutine imp(a)

    type(OBJ_MAT), intent(in) :: ainteger(kind =2) :: i

    print "(//, a, /)", " Matrice : "do i=1,a%n

    print (*(f6.2)),a%mat(i,:) ! * dans format : Fortran 2008enddo

    end subroutine implogical function erreur ()

    integer iercd

    erreur = iercd() /= 0end function erreursubroutine imp_vp(vec)

    complex , dimension (:) :: vecinteger :: i

    print "(//, a, /)", " Valeurs propres : "do i=1,size(vec)

    print (" Valeur propre N.", i2, " : (", 1pe9.2, &" , ", 1pe9.2, ")"), i, real(vec(i)), aimag(vec(i))

    end doend subroutine imp_vp

    end module matrix

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 288 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 10 (suite)

    program exo10use matrixtype(OBJ_MAT) :: ureal , dimension (:), allocatable :: val_initcomplex , dimension (:), allocatable :: val_pr

    open(unit=10, file="exo10.data", form="formatted", action="read")read(10, advance="no", fmt="(i1)") nb_lignesnb_col = nb_lignesallocate(val_init(nb_lignes*nb_col ))allocate(val_pr(nb_col ))read(10, *) val_initclose (10)u = val_initdeallocate(val_init)call imp(u)!---------------val_pr = .vp. u

    !---------------if (erreur ()) then

    print *,"La mthode diverge"else

    call imp_vp(val_pr)end ifdeallocate(val_pr)call poubelle(u)

    end program exo10

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 289 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 11

    module musicimplicit noneinteger , parameter :: nb_enr =30integer :: nb_mus!-----------------------------------------------type musicien

    privatecharacter(len =16) :: prenomcharacter(len =21) :: nominteger :: annee_naiss ,annee_mort

    end type musicien!-----------------------------------------------type , private :: ptr_musicien

    type(musicien), pointer :: ptrend type ptr_musicien!-------------------------------------------------------------------------type(musicien), dimension(nb_enr), target :: tab_mustype(ptr_musicien), dimension (:), allocatable , private :: tab_ptr_musicien!-------------------------------------------------------------------------interface operator(

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 11 (suite)

    containssubroutine init

    integer :: etat ,i! Valorisation du tableau de musiciensopen(1,file="musiciens",action="read",status="old")nb_mus = 0do

    read(1,"(a,1x,a,2(1x,i4))", iostat=etat) tab_mus(nb_mus +1)if (etat /= 0) exitnb_mus = nb_mus + 1

    enddoclose (1)!! On alloue le tableau de pointeurs dont le nombre! dlments correspond au nombre de musiciens.!allocate(tab_ptr_musicien(nb_mus ))!! Chaque lment du tableau de pointeurs allou prcdemment va tre mis! en relation avec llment correspondant du tableau de musiciens.! Chaque lment du tableau de musiciens tab_mus a lattribut target ! implicitement car cet attribut a t spcifi pour le tableau lui -mme.!do i=1,nb_mus

    tab_ptr_musicien(i)%ptr => tab_mus(i)enddoprint *,"---- Liste des musiciens ----"print *write(*,"((5x,a,1x,a,2(1x,i4)))") (tab_mus(i),i=1,nb_mus)

    end subroutine init

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 291 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 11 (suite)

    subroutine tri(critere)! Procdure triant la liste des musiciens par ordre alphabtique des noms! ou par ordre chronologique en fonction du paramtre critere spcifi.! Ce tri seffectue par lintermdiaire du tableau de pointeurs tab_ptr_musicien .! Dclaration de largumentcharacter(len=*), intent(in) :: critere! Dclarations localescharacter(len=*), parameter , dimension (2) :: labels = &

    [ "alphabetique ", "chronologique" ]character(len=len(labels )) :: label_trilogical :: exprinteger :: i, j!do i=nb_mus -1,1,-1

    do j=1,iselect case(critere)

    case("nom")label_tri = labels (1)expr = tab_ptr_musicien(j)%ptr%nom > &

    tab_ptr_musicien(j+1)% ptr%nomcase("annee")

    label_tri = labels (2)expr = tab_ptr_musicien(j)%ptr%annee_naiss > &

    tab_ptr_musicien(j+1)% ptr%annee_naissend selectif (expr) &

    !---------Permutation des deux associations ---------tab_ptr_musicien(j:j+1) = tab_ptr_musicien(j+1:j:-1)!---------------------------------------------------

    enddoenddo!print "(/, a, a, a, /)", "---- Liste ", trim(label_tri), " des musiciens ----"write(*,"((5x,a,1x,a,2(1x,i4)))") (tab_ptr_musicien(i)%ptr ,i=1,nb_mus)end subroutine tri

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 292 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 11 (suite)

    function longevite(mus1 ,mus2)!-- Fonction surchargeant loprateur < afin de pouvoir spcifier!-- des oprandes de type musicien .type(musicien), intent(in) :: mus1 ,mus2logical :: longeviteinteger :: duree_de_vie_mus1 , &

    duree_de_vie_mus2duree_de_vie_mus1 = mus1%annee_mort - mus1%annee_naissduree_de_vie_mus2 = mus2%annee_mort - mus2%annee_naisslongevite = duree_de_vie_mus1 < duree_de_vie_mus2

    end function longevite!----------------------function mort_le_plus_jeune(tab_mus)

    ! procdure de dfinition de loprateur .MortLePlusJeune. type(musicien), dimension (:), intent(in) :: tab_mustype(musicien) :: mort_le_plus_jeuneinteger i

    mort_le_plus_jeune = tab_mus (1)do i=2,nb_mus

    ! Ici lutilisation de loprateur < provoque lappel la fonction longevite :! tab_mus(i) < mus longevite(tab_mus(i),mus)

    if (tab_mus(i) < mort_le_plus_jeune) mort_le_plus_jeune = tab_mus(i)enddo

    end function mort_le_plus_jeune!---------------------------------function nom(mus)

    !-- Fonction renvoyant les nom et prnom du musicien pass en argument.type(musicien), intent(in) :: muscharacter(len =38) :: nom

    nom = trim(mus%prenom )//" "//mus%nomend function nom

    end module music

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 293 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane simple

    module musicimplicit none!type musicien

    privatecharacter(len =16) :: prenomcharacter(len =21) :: nominteger :: annee_naiss ,annee_morttype(musicien), pointer :: ptr

    end type musicien!---------------------------------type(musicien), pointer :: debut!---------------------------------interface operator(

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane simple (suite)

    containssubroutine init

    type(musicien) :: mustype(musicien), pointer :: ptr_precedent , ptr_courantinteger :: etat

    nullify(debut)nullify(mus%ptr)open(1,file="musiciens",action="read",status="old")do

    read(1,"(a,1x,a,2(1x,i4))",iostat=etat) mus%prenom , &mus%nom , &mus%annee_naiss , &mus%annee_mort

    if (etat /= 0) exitallocate(ptr_courant)if (.not.associated(debut )) then

    debut => ptr_courantelse

    ptr_precedent%ptr => ptr_courantendifptr_precedent => ptr_courantptr_courant = mus

    enddoclose (1)print *print *,"---- Liste des musiciens ----"print *call liste

    end subroutine init

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 295 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane simple (suite)

    subroutine tri(critere)! Procdure triant la liste des musiciens par ordre alphabtique des noms! ou par ordre chronologique en fonction du paramtre critere spcifi.character(len=*), intent(in) :: critere! Dclarations localescharacter(len=*), parameter , dimension (2) :: labels = &

    [ "alphabetique ", "chronologique" ]character(len=len(labels )) :: label_tritype(musicien), pointer :: ptr_courant , ptr_precedent , templogical :: tri_termine , exprdo

    tri_termine = .true. ; ptr_courant => debut ; ptr_precedent => debutdo

    if (.not.associated(ptr_courant%ptr)) exitselect case(critere)

    case("nom")label_tri = labels (1) ; expr = ptr_courant%nom > ptr_courant%ptr%nom

    case("annee")label_tri = labels (2) ; expr = ptr_courant%annee_naiss > &

    ptr_courant%ptr%annee_naissend selectif (expr) then

    if (associated(ptr_courant , debut)) thendebut => ptr_courant%ptr

    elseptr_precedent%ptr => ptr_courant%ptr

    end ifptr_precedent => ptr_precedent%ptr ; temp => ptr_courant%ptr%ptrptr_courant%ptr%ptr => ptr_courant ; ptr_courant%ptr => temptri_termine = .false. ; cycle

    end ifptr_precedent => ptr_courantif (associated(ptr_courant%ptr)) ptr_courant => ptr_courant%ptr

    end doif (tri_termine) exit

    end doprint *; print *,"---- Liste ", trim(label_tri), " des musiciens ----"; print *call liste

    end subroutine tri

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 296 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane simple (suite)

    function longevite(mus1 ,mus2)! Fonction surchargeant loprateur < afin de pouvoir spcifier des! oprandes de type musicien .type(musicien), intent(in) :: mus1 ,mus2logical :: longeviteinteger :: duree_de_vie_mus1 , duree_de_vie_mus2

    duree_de_vie_mus1 = mus1%annee_mort - mus1%annee_naissduree_de_vie_mus2 = mus2%annee_mort - mus2%annee_naisslongevite = duree_de_vie_mus1 < duree_de_vie_mus2

    end function longevitefunction mort_le_plus_jeune(debut)

    type(musicien), intent(in) :: debuttype(musicien) :: mort_le_plus_jeunetype(musicien), pointer :: p_mus

    mort_le_plus_jeune = debut; p_mus => debut%ptrdo while(associated(p_mus ))

    ! Ici lutilisation de loprateur < provoque lappel la fonction longevite :! p_mus < mort_le_plus_jeune longevite(p_mus, mort_le_plus_jeune)

    if (p_mus < mort_le_plus_jeune) mort_le_plus_jeune = p_musp_mus => p_mus%ptr

    enddoend function mort_le_plus_jeune!---------------------------------function nom(mus)

    ! Fonction renvoyant les nom et prnom du musicien pass en argument.type(musicien), intent(in) :: muscharacter(len =38) :: nomnom = trim(mus%prenom )//" "//mus%nom

    end function nom

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 297 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane simple (suite)

    subroutine listetype(musicien), pointer :: ptr_courant

    ptr_courant => debutif (.not.associated(debut )) then

    print *,"Il nexiste aucun musicien !"stop 8

    end ifdo

    write(*,"((5x,a,1x,a,2(1x,i4)))") ptr_courant%prenom , &ptr_courant%nom , &ptr_courant%annee_naiss , &ptr_courant%annee_mort

    if (.not.associated(ptr_courant%ptr)) exitptr_courant => ptr_courant%ptr

    end doend subroutine liste

    end module music

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 298 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane double

    module musicimplicit none!type musicien

    privatecharacter(len =16) :: prenomcharacter(len =21) :: nominteger :: annee_naiss ,annee_morttype(musicien), pointer :: ptr_precedent , ptr_suivant

    end type musicien!---------------------------------type(musicien), pointer :: debut!---------------------------------interface operator( ptr_courantptr_courant%ptr_precedent => ptr_precedent

    endifptr_precedent => ptr_courant

    enddoclose (1)print *print *,"---- Liste des musiciens ----"print *call liste

    end subroutine init

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 300 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane double (suite)

    subroutine tri(critere)! Procdure triant la liste des musiciens par ordre alphabtique des noms! ou par ordre chronologique en fonction du paramtre critere spcifi.! Dclaration de largumentcharacter(len=*), intent(in) :: critere! Dclarations localescharacter(len=*), parameter , dimension (2) :: labels = &

    [ "alphabetique ", "chronologique" ]character(len=len (labels )) :: label_tritype(musicien), pointer :: ptr_courant , ptrlogical :: tri_termine , expr

    dotri_termine = .true.ptr_courant => debutdo

    if(.not.associated(ptr_courant%ptr_suivant ))exitselect case(critere)

    case("nom")label_tri = labels (1)expr = ptr_courant%nom > ptr_courant%ptr_suivant%nom

    case("annee")label_tri = labels (2)expr = ptr_courant%annee_naiss > ptr_courant%ptr_suivant%annee_naiss

    end selectif (expr) then

    allocate(ptr)ptr = ptr_courant%ptr_suivantcall insere(ptr_courant , ptr)call suppression(ptr_courant%ptr_suivant)tri_termine = .false.cycle

    end ifif (associated(ptr_courant%ptr_suivant )) ptr_courant => ptr_courant%ptr_suivant

    end doif (tri_termine) exit

    end doprint *; print *,"---- Liste ",trim(label_tri)," des musiciens ----";print *;call liste

    end subroutine tri

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 301 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane double (suite)

    subroutine insere(ptr_courant , ptr)type(musicien), pointer :: ptr_courant , ptr

    if (associated(ptr_courant , debut)) thendebut => ptr

    elseptr_courant%ptr_precedent%ptr_suivant => ptr

    end ifptr%ptr_suivant => ptr_courantptr%ptr_precedent => ptr_courant%ptr_precedentptr_courant%ptr_precedent => ptr

    end subroutine insere!--------------------------subroutine suppression(ptr)

    type(musicien), pointer :: ptrtype(musicien), pointer :: temp

    temp => ptr ; ptr => ptr%ptr_suivantif (associated(temp%ptr_suivant )) &

    temp%ptr_suivant%ptr_precedent => temp%ptr_precedentdeallocate(temp)

    end subroutine suppression!----------------------------function longevite(mus1 ,mus2)

    ! Fonction surchargeant loprateur < afin de pouvoir spcifier! des oprandes de type musicien .type(musicien), intent(in) :: mus1 ,mus2logical :: longeviteinteger :: duree_de_vie_mus1 , duree_de_vie_mus2

    duree_de_vie_mus1 = mus1%annee_mort - mus1%annee_naissduree_de_vie_mus2 = mus2%annee_mort - mus2%annee_naisslongevite = duree_de_vie_mus1 < duree_de_vie_mus2

    end function longevite

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 302 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane double (suite)

    function mort_le_plus_jeune(debut)type(musicien), intent(in) :: debuttype(musicien) :: mort_le_plus_jeunetype(musicien), pointer :: p_mus

    mort_le_plus_jeune = debut; p_mus => debut%ptr_suivantdo while(associated(p_mus ))

    ! Ici lutilisation de loprateur < provoque lappel la fonction longevite :! p_mus < mort_le_plus_jeune longevite(p_mus, mort_le_plus_jeune)

    if (p_mus < mort_le_plus_jeune) mort_le_plus_jeune = p_musp_mus => p_mus%ptr_suivant

    enddoend function mort_le_plus_jeune!----------------function nom(mus)

    ! Retourne les nom et prnom du musicien pass en argument.type(musicien), intent(in) :: muscharacter(len =38) :: nom

    nom = trim(mus%prenom )//" "//mus%nomend function nom

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 303 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : solution avec liste chane double (suite)

    subroutine listetype(musicien), pointer :: ptr_courantptr_courant => debutif (.not.associated(debut )) then

    print *,"Il nexiste aucun musicien!"stop 8

    end ifdo

    write(*,"((5x,a,1x,a,2(1x,i4)))") ptr_courant%prenom , &ptr_courant%nom , &ptr_courant%annee_naiss , &ptr_courant%annee_mort

    if (.not.associated(ptr_courant%ptr_suivant )) exitptr_courant => ptr_courant%ptr_suivant

    end doprint *print *,"Liste inverse"print *,"--------------"print *do

    write(*,"((5x,a,1x,a,2(1x,i4)))") ptr_courant%prenom , &ptr_courant%nom , &ptr_courant%annee_naiss , &ptr_courant%annee_mort

    if (associated(ptr_courant , debut)) exitptr_courant => ptr_courant%ptr_precedent

    end doend subroutine liste

    end module music

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 304 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : liste chane double (autre solution)

    Cette solution propose de trier la liste chane laide dun tableau de pointeur . Elle peut videmment tre adapte poursappliquer la liste chane simple. Notez que cette solution adopte le concept dencapsulation.

    module musicimplicit nonetype musicien

    privatecharacter(len =16) :: prenomcharacter(len =21) :: nominteger :: annee_naiss ,annee_morttype(musicien), pointer :: ptr_precedent => NULL()type(musicien), pointer :: ptr_suivant => NULL()

    end type musicien!type , private :: ptr_mus

    type(musicien), pointer :: ptrend type ptr_mus!--------------------------------------------------------------------type(musicien), pointer :: debut => NULL()type(ptr_mus), dimension (:), allocatable , private :: tab_ptr_musicieninteger , private :: nb_mus!--------------------------------------------------------------------interface operator( ptr_courantptr_courant%ptr_precedent => ptr_precedent

    endifptr_precedent => ptr_courantnb_mus = nb_mus + 1

    enddoclose (1)call associationprint *; print *,"---- Liste des musiciens ----"; print *; call liste

    containssubroutine association

    integer i

    allocate( tab_ptr_musicien(nb_mus) )ptr_courant => debutdo i=1,nb_mus

    tab_ptr_musicien(i)%ptr => ptr_courantptr_courant => ptr_courant%ptr_suivant

    end doend subroutine association

    end subroutine init

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 306 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : liste chane double (autre solution : suite)

    subroutine tri(critere)! Procdure triant la liste des musiciens par ordre alphabtique des noms! ou par ordre chronologique en fonction du paramtre critere spcifi.! Dclaration de largumentcharacter(len=*), intent(in) :: critere! Dclarations localescharacter(len=*), parameter , dimension (2) :: labels = &

    [ "alphabetique ", "chronologique" ]character(len=len(labels )) :: label_trilogical :: exprinteger :: i, j

    do i=nb_mus -1,1,-1do j=1,i

    select case(critere)case("nom")

    label_tri = labels (1)expr = lgt(tab_ptr_musicien(j)%ptr%nom , tab_ptr_musicien(j+1)% ptr%nom)

    case("annee")label_tri = labels (2)expr = tab_ptr_musicien(j)%ptr%annee_naiss > &

    tab_ptr_musicien(j+1)% ptr%annee_naissend selectif (expr) &

    !-------Permutation des deux associations -----------tab_ptr_musicien(j:j+1) = tab_ptr_musicien(j+1:j:-1)!---------------------------------------------------

    enddoenddo

    print *print *,"---- Liste ", trim(label_tri), " des musiciens ----"print *call liste

    end subroutine tri

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 307 / 317

    Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : liste chane double (autre solution : suite)

    function longevite(mus1 ,mus2)! Fonction permettant de surcharger loprateur < afin de pouvoir spcifier! des oprandes de type musicien .

    type(musicien), intent(in) :: mus1 ,mus2logical :: longeviteinteger :: duree_de_vie_mus1 ,duree_de_vie_mus2

    duree_de_vie_mus1 = mus1%annee_mort - mus1%annee_naissduree_de_vie_mus2 = mus2%annee_mort - mus2%annee_naisslongevite = duree_de_vie_mus1 < duree_de_vie_mus2

    end function longevite!---------------------------------function mort_le_plus_jeune(debut)

    type(musicien), intent(in) :: debuttype(musicien) :: mort_le_plus_jeunetype(musicien), pointer :: p_mus

    mort_le_plus_jeune = debut; p_mus => debut%ptr_suivantdo while(associated(p_mus ))

    ! Ici lutilisation de loprateur < provoque lappel la fonction longevite :! p_mus < mort_le_plus_jeune longevite(p_mus, mort_le_plus_jeune)

    if (p_mus < mort_le_plus_jeune) mort_le_plus_jeune = p_musp_mus => p_mus%ptr_suivant

    enddoend function mort_le_plus_jeune

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 308 / 317

  • Annexe B : exercices Exercices : corrigs

    Corrig de lexercice 12 : liste chane double (autre solution : suite)

    function nom(mus)! Fonction renvoyant les nom et prnom du musicien pass en argument.

    type(musicien), intent(in) :: muscharacter(len =38) :: nom

    nom = trim(mus%prenom )//" "//mus%nomend function nom!---------------subroutine liste

    integer i

    if ( nb_mus == 0 ) thenprint *,"Il nexiste aucun musicien!"stop 8

    end ifdo i=1,nb_mus

    write(*,"((5x,a,1x,a,2(1x,i4)))") tab_ptr_musicien(i)%ptr%prenom , &tab_ptr_musicien(i)%ptr%nom , &tab_ptr_musicien(i)%ptr%annee_naiss , &tab_ptr_musicien(i)%ptr%annee_mort

    end doprint *print *,"liste inverse"print *,"--------------"print *do i=nb_mus ,1,-1

    write(*,"((5x,a,1x,a,2(1x,i4)))") tab_ptr_musicien(i)%ptr%prenom , &tab_ptr_musicien(i)%ptr%nom , &tab_ptr_musicien(i)%ptr%annee_naiss , &tab_ptr_musicien(i)%ptr%annee_mort

    end doend subroutine liste

    end module music

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 309 / 317

    Annexe C : apports de la norme 95

    15 Annexe A : paramtre KIND et prcision des nombres

    16 Annexe B : exercices

    17 Annexe C : apports de la norme 95Procdures pure Procdures elemental Le bloc FORALL

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 310 / 317

  • Annexe C : apports de la norme 95 Procdures pure

    Procdures pure

    Afin de faciliter loptimisation et la paralllisation des codes, la norme 95 a prvu unnouvel attribut pure attach aux procdures pour lesquelles ont peut garantir labsencedeffet de bord (side effect). Elles pourront ainsi figurer au sein du bloc FORALL vuci-aprs.Le prfixe pure doit tre ajout linstruction function ou subroutine.

    Exemple

    pure function ftc(a,b)implicit noneinteger ,intent(in) :: a, breal :: ftcftc = sin (0.2+ real(a)/( real(b)+0.1))

    end function ftc

    Voici brivement, ce qui leur est interdit : modifier des entits (arguments, variables) vues de lextrieur ; dclarer des variables locales avec lattribut SAVE (ou ce qui revient au mme lesinitialiser la dclaration) ;

    faire des entres/sorties dans un fichier externe.Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 311 / 317

    Annexe C : apports de la norme 95 Procdures pure

    Voici quelques rgles respecter : ne faire rfrence qu des procdures ayant aussi lattribut pure et obligatoirementen mode dinterface explicite ;

    toujours dfinir la vocation (intent) des arguments muets (sauf ceux de typeprocdural bien sr) : pour les fonctions cette vocation est obligatoirementintent(in) ;

    pour toute variable vue par host ou use association ou via COMMON ou via unargument muet avec intent(in) :

    ne pas la faire figurer gauche dune affectation, ne pas la faire figurer droite dune affectation si elle est de type driv contenant un

    pointeur, ne pas la transmettre une autre procdure si largument muet correspondant a lun

    des attributs : pointer, intent(out), intent(inout) ; ne pas lui associer de pointeur.

    ne pas utiliser dinstruction STOP ; les fonctions (ou sous-programmes) surchargeant des oprateurs (ou laffectation)doivent avoir lattribut pure.

    Remarques les fonctions intrinsques ont toutes lattribut pure, lattribut pure est automatiquement donn aux procdures ayant lattributelemental (cf. ci-aprs).

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 312 / 317

  • Annexe C : apports de la norme 95 Procdures elemental

    Procdures elemental

    Les procdures ELEMENTAL sont dfinies avec des arguments muets scalaires maispeuvent recevoir des arguments dappels qui sont des tableaux du mme type.La gnralisation du traitement scalaire lensemble des lments du/des tableaux passsou retourns suppose bien sr le respect des rgles de conformance au niveau des profils(shape).Voici les rgles respecter :

    ncessit dajouter le prfixe ELEMENTAL linstruction function ou subroutine ; lattribut ELEMENTAL implique lattribut pure ; il faut donc respecter toutes les rglesnonces au paragraphe prcdent sur les procdures pure ;

    tous les arguments muets et la valeur retourne par une fonction doivent tre desscalaires sans lattribut pointer ;

    si un tableau est pass un sous-programme ELEMENTAL , tous les autresarguments vocation in/inout doivent eux aussi tre passs sous forme detableaux et tre conformants ;

    pour des raisons doptimisation, un argument muet ne peut figurer dans unespecification-expr. c.--d. tre utilis dans les dclarations pour dfinir lattributDIMENSION dun tableau ou la longueur (len) dune variable de type character ;

    lattribut ELEMENTAL est incompatible avec lattribut RECURSIVE.Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 313 / 317

    Annexe C : apports de la norme 95 Procdures elemental

    Exemple

    module mod1integer ,parameter :: prec=selected_real_kind (6 ,30)

    end module mod1

    program P1USE mod1implicit nonereal(kind=prec) :: scal1 ,scal2real(kind=prec),dimension (1024) :: TAB1 ,TAB2

    . . . . . .call permut(scal1 ,scal2)

    . . . . . .call permut(TAB1 ,TAB2)

    . . . . . .contains

    elemental subroutine permut(x,y)real(kind=prec),intent(inout) :: x, yreal :: temptemp = xx = yy = temp

    end subroutine permutend program P1

    Note : un oprateur surcharg ou dfini via une fonction ELEMENTAL est lui mme"lmentaire" ; il peut sappliquer des oprandes qui sont des tableaux de mme typeque ses oprandes scalaires.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 314 / 317

  • 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 dinstructions

    END FORALL [etiquette]

    Le bloc FORALL est utilis pour contrler lexcution dinstructions daffectation oudassociation (pointeur) en slectionnant des lments de tableaux via des tripletsdindices et un masque optionnel. Le bloc peut se rduire une instruction FORALL sil ne contient quune seule instruction.Ce bloc a t dfini pour faciliter la distribution et lexcution des instructions du bloc, enparallle sur plusieurs processeurs.Sous le contrle du masque , chacune des instructions est interprte de faonanalogue une "instruction tableau" ; les oprations lmentaires sous-jacentes doiventpouvoir sexcuter simultanment ou dans nimporte quel ordre, laffectation finalentant faite que lorsquelles sont toutes termines.La squence des instructions dans le bloc est respecte.La porte (scope) dun indice (index) contrlant un bloc FORALL est limite cebloc. En sortie du bloc, une variable externe de mme nom retrouve la valeur quelle avaitavant lentre.

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 315 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    Exemples

    1 Traitement particulier des lignes paires et impaires dune matrice A(NL,NC) (NL pair)en excluant les lments nuls. Le traitement des lignes impaires prcde celui deslignes paires :FORALL(i=1:NL -1:2, j=1:NC -1, A(i,j) /= 0.)

    A(i,j) = 1./A(i,j)A(i+1,j)= A(i+1,j)*A(i,j+1)

    END FORALL

    Avec une double boucle DO, les oprations lmentaires et les affectations se feraientdans lordre strict des itrations : les rsultats seraient diffrents.

    2 Inversion de chaque ligne du triangle infrieur dune matrice carre dordre N :exter:FORALL(i=2:N)

    inter:FORALL(j=1:i)A(i,j) = A(i,i-j+1)

    END FORALL interEND FORALL exter

    3 Forme plus condense en considrant chaque ligne comme une section rgulire eten adoptant la syntaxe de l instruction FORALL :FORALL(i=2:N) A(i,1:i) = A(i,i:1:-1)

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 316 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    Transformation ligne par ligne dun tableau A de N lignes et stockage du rsultat dans letableau B. Utilisation dun bloc WHERE et appel de fonctions intrinsques ou ayantlattribut pure dans le corps du bloc FORALL.

    Exemples (suite)

    program transformimplicit noneinteger ,parameter :: N=5, M=8real , dimension(N,M) :: A, B

    . . . .FORALL(i=1:N)

    WHERE(abs(A(i,:)) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139, 205, 219, 293=> (use) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .221(/ ... /) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 75( :,... ,) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285( :,... , :) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75, 123.EQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.GE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.GT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.LE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.LT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27.NE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27: : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49, 201, 205, 293& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25tat pointeur

    associ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137indfini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137nul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

    tendue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39, 71, 73, 81

    A achar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

    open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229adjustl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257adjustr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257advance

    read/write . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231, 233affectation

    surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197, 219affectation et allocation automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131aiguillage - select case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67alias

    pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137all . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91, 279ALLOCATABLE

    composante type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127, 129scalaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    allocatable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 55, 125, 127, 157, 277, 285, 291allocate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 55, 125, 143, 149, 151, 157, 159, 201, 203, 205, 219, 277, 285, 293allocated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125, 215, 219allocation via affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131ANSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11any . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91, 97, 219argument procdural . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183arguments

    ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243arguments mot cl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165, 191arguments optionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165, 191ASA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11associated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147, 159association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217assumed-shape-array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83assumed-size-array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 181

    B bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17bloc interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 83, 169, 171, 175, 183, 191bloc interface nomm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67, 69boucles implicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

    C case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293case default . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67case( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67champs

    type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137, 139COMMAND_ARGUMENT_COUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27, 29common . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .157, 175, 213compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23composantes

    pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45conformance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91constantes denvironnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229constructeur

    structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

    constructeur de type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47contains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 167, 169, 175contrle

    procdure 77 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191count . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93, 107, 279cpu_time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 247, 249cross-compilateur NEC sxf90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23cshift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101, 103, 107, 119, 277

    drive dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103cycle - do/end do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63

    D dclarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29, 31, 33drive dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247date_and_time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247, 251deallocate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125, 127, 143, 149, 285deffered-shape-array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125delim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

    open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229digits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245dim

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

    E E./S. et type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53edition de liens

    dition de liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    elemental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15, 315elsewhere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113, 115encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207end select . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67end=

    read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231, 233environnement

    constantes d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229eor=

    read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231, 233eoshift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103, 105, 107epsilon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245equivalence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253ERROR_UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229execution

    excution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23exit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293exit - do/end do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61, 63exponent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .245expression

    dinitialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117de specification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

    external . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13, 31, 183

    F f90 (IBM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23, 273fonction valeur chane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .179fonction valeur pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179fonction valeur tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .179fonction intrinsque

    kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37fonctions lmentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115fonctions intrinsques

    kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37selected_int_kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37, 39, 41selected_real_kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37, 39, 41

    forall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 319format fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29format libre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25, 27Fortran

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19fortran 2003 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13fortran 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13fortran 66 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11fortran 77 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11fortran 90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13fortran 95 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13fortran IV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11fortran V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

    Fortran 95 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 45, 55, 89, 115, 117, 137, 147, 213, 215, 217, 237, 247, 259fraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

    G gnrique

    interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185gather - scatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77GET_COMMAND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241GET_COMMAND_ARGUMENT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241GET_ENVIRONMENT_VARIABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243global - local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

    H host association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51, 127huge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

    I iachar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255iand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257ibclr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259ibits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259IBM/SP6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261ibset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259ichar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255identificateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25ieor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257if - then - else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59implicit none . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    index - fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117initialisation-expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117INPUT_UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229inquire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231int - fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117INT16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35INT32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35INT64 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35INT8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35intent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 31, 165, 173, 201, 205, 295interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285interface assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203, 215, 219, 291interface explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83, 123, 165, 167, 169, 171, 175

    obligatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179interface gnrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185, 191interface implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163interface operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201, 203, 213, 291internes

    procdures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167, 169internes - procdures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23intrinsic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31iolength . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231iomsg=

    read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233, 235ior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257iostat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61, 63, 231, 279, 281, 283iostat=

    read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233, 235IOSTAT_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229IOSTAT_EOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229ishft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257ishftc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257ISO_FORTRAN_ENV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229

    K KIND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33, 35kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15, 35, 117, 261, 285, 315

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    L lbound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87len_trim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257, 279, 281, 283lge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255lgt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255ligne de commande

    arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243linariser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107liste chane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55, 159lle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255llt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255local - global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169logiques

    oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

    M mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213makedepf90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .273mask

    fonctions tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89masque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89, 93, 95, 113matmul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95, 97, 119matrice tridiagonale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109maxloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89maxval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93, 119merge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111, 113mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207minloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89minval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93module procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187, 201, 203, 213modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 23, 175, 187, 201, 207, 219, 291mot-cl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25mots-cl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

    arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167MOVE_ALLOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133mvbits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

    N namelist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    nearest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .245NEC-SX8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23NEC/SX8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261Norme 2003 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127norme 2003 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47norme 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67, 69Norme 95 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 137, 147, 159, 213nullify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147, 149, 215NUMERIC_STORAGE_SIZE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

    O oprateur

    (nouvel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

    action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229delim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229pad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229, 231status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

    operateuroprateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

    optional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 31, 165, 167, 173, 191order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99OUTPUT_UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

    P pack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .107, 109, 119, 277, 279pad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13, 99, 231

    open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 33, 55, 173pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 55, 139, 291

    champ de structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55pointeur

    tat nul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143, 147descripeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137oprateur = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    rcursivit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55, 137, 157, 159, 217

    alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

    positionopen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

    prcision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37, 39precision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245prcision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41present . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 165, 173, 191private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31, 207, 209, 291procdural

    argument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183procdures internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167, 169product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95, 119profil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71, 73, 77, 87, 97, 173public . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 207, 209pure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 313

    R rallocation et affectation automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131rallocation via affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131rcursif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223rcursivit

    pointeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159random_number . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247, 249, 275random_seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247, 249, 275rang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71, 73, 75, 77, 87, 157range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41, 245real - fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117REAL128 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35REAL32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35REAL64 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35recl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231rcursif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15recursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257reshape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .75, 97, 105, 107, 109, 111, 117, 119, 201, 275, 277, 285result . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223RS/SP6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    S save . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13, 31, 33, 127scalaire

    ALLOCATABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129scan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257scatter - gather . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77scoping unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169sections de tableaux - procdures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83sections irrgulires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79sections rgulires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77select case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 67, 293selected_int_kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39, 117selected_real_kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39, 117, 315sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51, 55shape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87, 119, 219, 277sign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247size . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81, 87, 117, 119, 123, 277, 285size=

    read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231sous-types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35spacing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245specification part : module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169specification-expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123spread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109, 113, 275static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33status

    open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23, 45, 217structures de contrle

    SELECT CASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95, 97, 119, 277surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15surcharge doprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73, 197SX8-NEC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23sxf90 : cross-compilateur NEC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23system_clock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247, 249

    T tableau

    constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    Annexe C : apports de la norme 95 Le bloc FORALL

    pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151, 153profil diffr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157sections non rgulires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85

    tableauxautomatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123conformants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71, 73dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125profil diffr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125profil implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83sections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77sections irrgulires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79taille implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .81

    tableaux automatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125, 127taille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71, 73, 81, 87, 173target . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55, 127, 139, 291tests

    SELECT CASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247tiny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .245trace - matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119, 277traceback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219transfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117, 253, 279transpose . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .111, 119, 203tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153trim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117, 257type driv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 285

    composante ALLOCATABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127, 129constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

    type driv et E./S. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53type driv semi-priv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .211types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

    U ubound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87unpack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107, 109use . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23, 127, 169, 201, 207

    clause only . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .219, 221use association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51, 127, 181

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

  • Annexe C : apports de la norme 95 Le bloc FORALL

    V vecteurs dindices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79verify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257vocation

    arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

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

    Z zro positif/ngatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

    Patrick Corde Herv Delouis ( Patrick.Corde@idris.fr ) Langage Fortran(Avanc) 4 juillet 2018 317 / 317

    IntroductionHistoriqueCompatibilit norme 77/90 Apports de Fortran 90Apports de Fortran 95bibliographiedocumentation

    GnralitsStructure d'un programmeCompilation, dition des liens, excution lments syntaxiques

    Types drivsDfinition et dclaration de structuresInitialisation (constructeur de structure)Constructeur de structure : norme 2003Symbole % d'accs un champTypes drivs et procduresTypes drivs et entres/sorties

    Programmation structureIntroductionBoucles DOLe bloc SELECT-CASELa structure block

    Extensions tableauxDfinitions (rang, profil, tendue, ...)Manipulations de tableaux (conformance, constructeur, section, taille, ...)Initialisation de tableauxSections de tableauxSections irrguliresTableau en argument d'une procdure (taille et profil implicites)Section de tableau non contigu en argument d'une procdureFonctions intrinsques tableauxInstruction et bloc WHEREExpressions d'initialisationExemples d'expressions tableaux

    Gestion mmoireExpressions de spcificationTableaux automatiquesTableaux dynamiques ALLOCATABLE, profil diffrArgument muet ALLOCATABLE : norme 2003Composante allouable d'un type driv : norme 2003Allocation d'un scalaire ALLOCATABLE : norme 2003Allocation/rallocation via l'affectation : norme 2003Procdure MOVE_ALLOC de rallocation : norme 2003

    PointeursDfinition, tats d'un pointeurDclaration d'un pointeurSymbole =>Symbole = appliqu aux pointeursAllocation dynamique de mmoireImbrication de zones dynamiquesFonction NULL() et instruction NULLIFYFonction intrinsque ASSOCIATEDSituations viterDclaration de tableaux de pointeurs Passage d'un pointeur en argument de procdurePassage d'une cible en argument de procdurePointeur, tableau profil diffr et COMMONListe chane

    Interface de procdures et modulesInterface implicite : dfinitionInterface implicite : exempleArguments : attributs INTENT et OPTIONALPassage d'arguments par mot-clInterface explicite : procdure interneInterface explicite : 5 possibilitsInterface explicite : bloc interfaceInterface explicite : ses apportsInterface explicite : module et bloc interfaceInterface explicite : module avec procdureCas d'interface explicite obligatoireArgument de type procdural et bloc interface

    Interface gnriqueIntroductionExemple avec module procedureExemple : contrle de procdure F77

    Surcharge ou cration d'oprateursIntroductionInterface operatorInterface assignment

    Contrle de visibilit, concept d'encapsulation et gestion de zones dynamiquesIntroductionInstructions PRIVATE et PUBLICAttributs PRIVATE et PUBLICType driv semi-privExemple avec contrle de la visibilitParamtre ONLY de l'instruction USE

    Procdures rcursivesClauses RESULT et RECURSIVEExemple : suite de Fibonacci

    Nouveauts sur les E/SAccs aux fichiers pr-connectsOPEN (status, position, pad, action, delim)INQUIRE (recl, action, iolength,...)Entres-sorties sur les fichiers texte (advance='no')Paramtres IOSTAT et IOMSG de l'instruction READParamtres IOSTAT et IOMSG de l'instruction READInstruction NAMELISTSpcification de format minimum

    Nouvelles fonctions intrinsquesAccs l'environnement, ...Prcision/codage numrique : tiny/huge, sign, nearest, spacing, ...Mesure de temps, date, nombres alatoiresTransformation (transfer)Conversion entiers/caractres (char, ichar, ...)Comparaison de chanes (lge, lgt, lle, llt)Manipulation de chanes (adjustl, index, ...)Oprations sur les bits (iand, ior, ishft, ...)

    AnnexeAnnexe A : paramtre KIND et prcision des nombresSur IBM/SP6Sur NEC/SX8

    Annexe B : exercicesnoncsExercices : corrigs

    Annexe C : apports de la norme 95Procdures pure Procdures elemental Le bloc FORALL

Recommended

View more >