Cours Module et Types dérivés en Fortran 95 pdf


Télécharger Cours Module et Types dérivés en Fortran 95 pdf
3.53.5 étoiles sur 5 a partir de 1 votes.
Votez ce document:

Télécharger aussi :


? 1954, naissance de Fortran (John Backus, IBM).

? 1956, Fortran I (nom des variables jusqu’a` 6 caractères et introduction de l’instruction format.

? 1957, Fortran II (premier compilateur, notions de sous-programme et de fonction).

? 1958, Fortran III est disponible mais ne sort pas de chez IBM (type logique, paramètres et prototypage des procédures).

? 1962, Fortran IV est le langage des scientifiques mais il faut établir une norme.

? 1966, Fortran IV est rebatisé Fortran 66 (norme ANSI : American National Standards Institut).

? 1978, c’est la fin des cartes perforées. La norme Fortran 77 (ou Fortran V) modernise le langage. On passe d’une programmation symbolique a` une programmation structurée.

norme est élaborée.

? 1991, Fortran 90 apparaˆ?t (norme internationale ISO/ANSI). Fortran devient modulaire et plus fiable. Il s’oriente vers une programmation objet (modules, récursivité, surcharge des opérateurs, types dérivés, etc.).

? 1995, Fortran 95 définit les instructions dépréciées ou obsolètes et introduit la structure forall et quelques autres extensions.

? 2002, Fortran 2000 (fin du processus de normalisation et publication de la norme ISO prévue fin 2004). Fortran supporte désormais la programmation objet.

? 2005, correction de Fortran 2000 et adoption de la norme dite (( Fortran 2003 )).

? A ce jour (mars 2009), la norme 2003 n’est que partiellement implémentée dans les compilateurs Fortran libres ou du marché.

                                                           2 – Introduction                                             5

2 – Introduction

Fortran est utilisé depuis plus d’un demi siècle dans des domaines scientifiques variés :

? climat,

? mécanique des fluides, ? physique, ? chimie.

? Commentaire sur une ligne d’instruction.

? Possibilités d’opérer sur des tableaux (ou section de tableau). ? Procédures récursives.

? Grouper les procédures et les données au sein d’un module.

? Profonde amélioration du mécanisme de passage d’arguments dans une procédure permettant leur vérification à la compilation.

? Interface des procédures génériques.

? Surcharge d’opérateur.

? Type dérivés.

? Nouvelle syntaxe pour la déclaration des types de variables.

? Allocation dynamique et pointers.

? Structure des boucles et sélection conditionnelle select ... case.

? Portabilité et controˆle de la précision numérique.

? Nouvelles procédures intrinsic.

                                                           2 – Introduction                                             6

La norme Fortran 90 a introduit des extensions majeures a` Fortran 77. Elle apporte des solutions efficaces (parfois encore partielles) concernant :

? la portabilité des codes sources,

? la fiabilité (précision numérique, controˆle d’erreurs par le compilateur), ? la performance du code assembleur généré par le compilateur, ? certaines contraintes de développement en génie logiciel.

Quelles sont ces extensions?

Ouvrages :

? Fortran 90/95 Explained de Michael Metcalf & John K. Reid (( This book is concerned with the Fortran programming language (Fortran 90 and Fortran 95), setting out a reasonably concise description of the whole language ... )). Ed. Oxford University Press.

? Manuel complet du langage Fortran 90 et Fortran 95. Calcul intensif et génie logiciel de Patrice Lignelet. Ed. Masson.

Liens :

? base/IDRIS Fortran

?

?

Compilateurs :

?

? links


                                                          4 – Généralités                                             9                                                          4 – Généralités                                            10

                                                                                                                                                                                   Programme principal : Module :

4 – Généralités

                                                                                                                                                                                      program amoi                           module alui

Un programme source Fortran est composé de parties indépendantes appelées unités de programme (scoping unit). Une unité de programme peut être :

? un programme principal (pouvant contenir des procédures internes),

? une procédure externe (sous-programme ou fonction), ? un module.

Chaque unité comprend une partie déclarative suivie d’une partie comportant des

instructions exécutables.                              Regardons de plus près quelques apports importants liés a` l’utilisation des modules...

5.1 – Sans module

program amoi



implicit none

integer, parameter       :: N=11 real*8, dimension(N,N) :: Au, Av real*8, dimension(N) :: Su, Sv real*8, dimension(N) :: u,v ...

call gmres(..., N, Au, Su, u) ... call mgrid(..., N, Av, Sv, v) ...

end program amoi

subroutine gmres(..., N, A, B, x)

implicit none

integer       :: N real*8, dimension(N,N) :: A real*8, dimension(N) :: B, x

... end subroutine gmres

subroutine mgrid(..., N, A, B, x)

implicit none

integer       :: N real*8, dimension(N,N) :: A real*8, dimension(N) :: B, x

...

end subroutine mgrid ...

amoi.f90 : utilisation alui.f90 : procédures

5 – Cas d’exemple

Il s’agit de définir une bibliothèque de procédures permettant la résolution d’un système linéaire A×x = B par différentes méthodes itératives.

> ifort -c amoi.f90

> ifort -c alui.f90

> ifort -o amoi.x amoi.o alui.o


5   – Cas d’exemple : avec module

5.2 – Avec module

alui mod.f90 : module

13

module alui

implicit none

public

integer,parameter :: d=selected_real_kind(15)

contains

subroutine gmres(..., A, B, x)

implicit none

real(kind=d),intent(in),dimension(:,:):: A real(kind=d),intent(in),dimension(:) :: B real(kind=d),intent(out),dimension(:) :: x ... end subroutine gmres

subroutine mgrid(..., A, B, x)

implicit none

real(kind=d),intent(in),dimension(:,:):: A real(kind=d),intent(in),dimension(:) :: B real(kind=d),intent(out),dimension(:) :: x ...

end subroutine mgrid ...

end module alui

program amoi use alui

implicit none

integer, parameter                                             :: N=11

real(kind=d), dimension(N,N) :: Au,Av real(kind=d), dimension(N) :: Su,Sv real(kind=d), dimension(N) :: u,v ...

call gmres(..., Au, Su, u) ... call mgrid(..., Av, Sv, v) ...

end program amoi

> ifort -c alui_mod.f90 > ifort -c -I. amoi.f90

> ifort -o amoi.x amoi.o alui_mod.o

amoi.f90 : utilisation

LABORATOIRE D’INFORMATIQUE POURLA MECANIQUE ET LES SCIENCES´                                                                                                                                                       Modules et Types dérivés en Fortran 95 – Mars 2009

DE L’INGENIEUR´                                                                                                                                                                                                                                                                                                                                                                                                                 Jalel Chergui

                           5 – Cas d’exemple : quelques avantages                   15

                         5 – Cas d’exemple : quelques avantages                   14

5.3 – Quelques avantages

? La possibilité de détecter, à la compilation, les erreurs liées a` la non-cohérence des arguments d’appels et des arguments muets.

? Plus besoin d’indiquer en argument les dimensions des tableaux. La transmission du profile et de la taille des tableaux est implicite et peuvent être connus graˆce aux fonctions respectivement shape et size.

? La vocation des arguments est controˆlée en fonction de l’attribut intent (et optional).

? Le controˆle de la visibilité des variables et des procédures en fonction des instructions (ou attributs) public et private.

? Le passage des arguments d’appels aurait pu se faire par mot-clé (voir exemple suivant).


program amoi use alui

implicit none

integer, parameter                                             :: N=11

real(kind=d), dimension(N,N) :: Au, Av real(kind=d), dimension(N) :: Su, Sv real(kind=d), dimension(N) :: u, v ... call gmres(..., B=Su, A=Au, X=u) ... call mgrid(..., X=v, B=Sv, A=Av) ...

end program amoi

Un mot-clé n’est autre que le nom donné a` l’argument muet d’une procédure définie dans un module ou un bloc interface.

                                               6 – Interface générique                                   17                                             7 – Vers une programmation objet     18

Dans l’exemple précédent, nous avons :



? créé une interface générique publique nommée solve,

? restreint avec l’attribut private la visibilité des procédures gmres et mgrid qui ne        7 – Vers une programmation objet pourront désormais être appelées d’une unité externe que via leur interface générique solve.

Jusqu’a` présent, toute modification des arguments muets relatifs aux procédures (gmres

Ainsi, le concepteur du module peut se réserver le droit de changer le nom des et mgrid) par le concepteur du module impacterait nécessairement l’unité de procédures privées sans impacter le programme utilisateur.         programme appelante (utilisateur).

Cependant, il peut être amené a` modifier le nombre et le type des arguments muets au grè des mises a` jour du module ...


               7 – Vers une programmation objet : application          21

alui mod.f90 : module

module alui

public

integer,parameter :: & d=selected_real_kind(15)

interface solve

module procedure pgmres,pmgrid

end interface solve private :: pgmres, pmgrid

type gmres private

real(kind=d):: tol=1.D-12,relax=1.85_d

integer :: maxiter=50 integer :: maxcomp=10 ... end type gmres

type mgrid private

real(kind=d) :: tol=1.D-12 integer :: maxiter=50 integer :: maxlevel=10 ...

end type mgrid

Encapsulation

? Les paramètres de controˆle (tol, relax, maxiter, etc.) des méthodes de résolution sont encapsulés dans les types dérivés semi-privés gmres et mgrid .

? Des valeurs par défaut sont assignées aux composantes privés.

LABORATOIRE D’INFORMATIQUE POURLA MECANIQUE ET LES SCIENCES´                                                                                                                                                       Modules et Types dérivés en Fortran 95 – Mars 2009

DE L’INGENIEUR´                                                                                                                                                                                                                                                                                                                                                                                                                 Jalel Chergui

               7 – Vers une programmation objet : application          23

Encapsulation (suite ...)

program amoi use alui

implicit none

integer, parameter                                             :: N=11

real(kind=d), dimension(N,N) :: Au,Av real(kind=d), dimension(N) :: Su,Sv

gmres mgrid

real(kind=d), dimension(N) :: u,v type( ) :: gm type( ) :: mg

... call solve(SOLVER=gm, A=Au, B=Su, X=u) ... call solve(SOLVER=mg, A=Av, B=Sv, X=v) ...

end program amoi

? L’appel des procédures de résolution est réalisé via leur interface générique amoi.f90 : utilisation solve.

? Les objets gm et mg, déclarés respectivement de types gmres et mgrid, permettent au compilateur de choisir l’une ou l’autre procédure de résolution.

Des méthodes (procédures publics facilitant la manipulation global d’objets privés ou semi-privés) permetteront de modifier les valeurs par défaut des composantes des types gmres et mgrid.

              7 – Vers une programmation objet : application          22

Suite...

contains subroutine pgmres(solver, A, B, x)

implicit none

real(kind=d),intent(in),dimension(:,:):: A real(kind=d),intent(in),dimension(:) :: B real(kind=d),intent(out),dimension(:) :: x

type(gmres), intent(inout) :: solver

integer :: it ...

do it=1, solver%maxiter ...

end do

end subroutine pgmres subroutine pmgrid(solver, A, B, x)

implicit none

real(kind=d),intent(in),dimension(:,:):: A real(kind=d),intent(in),dimension(:) :: B real(kind=d),intent(out),dimension(:) :: x

type(mgrid), intent(inout) :: solver

integer :: it ...

do it=1, solver%maxlevel ...

end do

end subroutine pmgrid end module alui

Encapsulation (suite ...)

? L’interface des procédures privées de résolution est modifiée.

? L’introduction de l’objet solver en argument permet de réduire a` 4 le nombre d’arguments muets.

? A noter que les noms des procédures privés, chargées de la résolution des systèmes linéaires, ont changé.


                    7 – Vers une programmation objet : application          25

Suite du module...



subroutine pgmres_set(solver, tol, relax, & maxiter, maxcomp)

implicit none

Procédure (( méthode )) (suite...) real(kind=d),intent(in),optional :: tol,relax

integer, intent(in), optional :: maxiter integer, intent(in), optional :: maxcomp

? L’objectif est de pouvoir appeler if(typepresent(gmres()tol)) solver%tol=tol, intent(inout) :: solver ces procédures en passant les ar- if(present(relax)) solver%relax=relax

              guments d’appel par mot clé pour if(if(presentpresent((maxiter)) solver%maxiter=maxitermaxcomp)) solver%maxcomp=maxcomp

               changer une valeur par défaut ou             end subroutine pgmres_set

antérieure d’une ou plusieurs com- subroutine pmgrid_set(solver, tol, maxiter, & posantes des types gmres et mgrid maxlevel)

             .                                                                          implicit nonereal(kind=d),intent(in),optional :: tol

         ? Si l’argument, supposé optionnel,                      integer, intent(in), optional :: maxiter

integer, intent(in), optional :: maxlevel

est présent alors affecter sa nou- type(mgrid), intent(inout) :: solver velle valeur a` la composante corres- if(present(tol)) solver%tol=tol

pondante du type dérivé. if(if(presentpresent((maxiter)) solver%maxiter=maxitermaxlevel)) solver%maxlevel=maxlevel

end subroutine pmgrid_set

Procédure (( méthode )) (suite...)

Le reste n’a de limite que celle de notre imagination...

? Gérer une composante dynamique privés dans un type dérivé (un compteur, un tableau dynamique, un pointer sur un autre type dérivé, etc.

? Définir les (( méthodes )) associées pour gérer ces nouveaux objets (les allouer, les initialiser, en extraire une valeur, les détruire, etc.)

               7 – Vers une programmation objet : application          26

Procédure (( méthode )) (suite...)

amoi.f90 : utilisation

program amoi use alui

implicit none

integer, parameter                                             :: N=11

real(kind=d), dimension(N,N) :: Au, Av real(kind=d), dimension(N) :: Su, Sv real(kind=d), dimension(N) :: u, v

type(gmres) :: gm type(mgrid) :: mg ...

call solve_set(SOLVER=gm,MAXCOMP=5) call solve(SOLVER=gm, A=Au, B=Su, X=u) ...

call solve_set(SOLVER=mg,MAXLEVEL=15) call solve(SOLVER=mg, A=Av, B=Sv, X=v) ...

end program amoi

? Par exemple, modifier les paramètres maxcomp et maxlevel avant résolution par gmres et mgrid.

8 – Quelques apports de Fortran 2003

Parmi les nombreuses extensions qui font aujourd’hui de Fortran un Langage Orienté Objet :

? Type dérivé : paramétrisation, extension, héritage, polymorphisme, etc.

? Module : notion de sous-module (expression d’un même module dans des unités de programmes différentes), permet de définir des bibliothèques de grande taille, de préserver le contenu secret pour des raisons commerciales par exemple, etc.

                                                            9 – Conclusion                                             29

9 – Conclusion

? Les modules offrent la possibilité de regrouper une famille de procédure sous un nom générique.

? A l’appel, le choix de la procédure a` exécuter est fait automatiquement par le compilateur en fonction du nombre et du type des arguments.

? Le concepteur d’un module a la possibilité de cacher (rendre non visible) certaines variables et/ou procédures définies a` l’intérieur de celui-ci.

? Les types dérivés est un moyen permettant d’encapsuler des données.

? La privatisation de certaines données conduit le concepteur a` fournir au développeur des (( méthodes )) (procédures publiques) facilitant la manipulation d’objets privés ou semi-privés.

? La documentation des ressources publiques d’un module est un aspect important de la programmation objet.


LABORATOIRE D’INFORMATIQUE POUR LA MECANIQUE ET LES SCIENCES´

DE L’INGENIEUR´


Modules et Types dérivés en Fortran 95 – Mars 2009

Jalel Chergui



153