Cours de Fortran les modules, tutoriel & guide de travaux pratiques en pdf.

STRUCTURE D’UN PROGRAMME ET SYNTAXE

UNITÉS DE PROGRAMME ET PROCÉDURES

De façon très générale, la taille des programmes que l’on est amené à développer aujourd’hui devient considérable. Les ordinateurs sont de plus en plus puissants, ils sont alors de plus en plus sollicités dans la vie courante. Et l’exigence de l’utilisateur n’a plus de limite. Quant aux chercheurs et à leurs désirs, rien ne saurait les décourager, pas même des dizaines de milliers de lignes de calculs. Or, dès que l’on envisage un travail un tant soit peu ambitieux, on a de plus en plus souvent besoin de compétences multiples. C’est-à-dire que les programmes sont développés par plusieurs personnes, qui hormis le langage informatique commun ne parlent pas forcément le même jargon technique.
C’est pourquoi, nous avons besoin d’un langage structuré et d’un langage modulaire. La structure permet une bonne lisibilité d’un programme, donc une bonne compréhension et une maîtrise du codage. C’est-à-dire que l’on résout effectivement le problème donné et pas un ersatz qui fonctionne dans 97 % des cas, voire moins ! La modularité permet de répondre aux besoins du Génie Logiciel. Les modules fonctionnent quasiment comme des boîtes noires, ce qui permet d’incorporer dans un programme des parties indépendantes les unes des autres et ne nécessitant pas forcément aux autres développeurs de prendre connaissance de leur contenu. Il suffit de connaître le nom d’appel des procédures dont on a besoin.
La notion d’objet est plus forte encore, et on les manipule alors complètement comme des boîtes noires. L’objet réalise lui-même l’encapsulation de ses données et empêche tout accès depuis l’extérieur.
En récapitulant, Fortran 90 facilite la manipulation des structures (objet de type dérivé), en offrant les possibilités suivantes.
– Il permet de définir des fonctions de manipulation de ces structures :
– surcharge des opérateurs +, -, * ,
– de nouveaux opérateurs en les associant aux fonctions correspondantes,
– autres fonctions ou procédures agissant sur ces structures ;
– Il permet d’encapsuler le type et les fonctions opérant sur les objets de ce type dans un module séparé. Ce qui permettra d’y accéder facilement (USE <module>) en diminuant les sources d’erreurs, dans toutes les unités de programme en ayant besoin ;
– Il permet de rendre privée les composantes de la structure. Si la définition du type se fait dans un module séparé (encapsulation), seules les fonctions ou procédures internes au module ont accès aux composantes privées (PRIVATE) et peuvent les modifier (sécurité).
Sans être un vrai langage orienté objet, Fortran 90 fournit ainsi des extensions objet bien utiles pour la structuration du programme et sa fiabilité.
Un programme est composé d’unités de programme, qui sont :
– un programme principal, contenant une procédure interne ;
– des procédures externes ;
– des modules.
Les procédures externes peuvent être écrites dans des modules, elles deviennent internes au module. Un module peut contenir des procédures, des déclarations, des affectations de variables, des types dérivés et des blocs interfaces.
Les mots clés sont :
PROGRAM, END PROGRAM ;
MODULE, END MODULE ;
CONTAINS ;
SUBROUTINE, END SUBROUTINE ;
FUNCTION, END FUNCTION.

Le programme principal

Le programme principal est une unité de compilation, mais il a la particularité d’être la seule qui soit exécutable. Donc il est la seule qui soit totalement obligatoire. Le programme principal prend toujours la forme suivante :
PROGRAM nom_du_programme [instructions de spécification] [instructions exécutables]
CONTAINS
[procédures internes]
END PROGRAM nom_du_programme
L’instruction PROGRAM est facultative, mais conseillée. L’instruction END qui génère l’arrêt du programme est obligatoire. Les instructions de spécification sont des instructions de déclaration, des définitions de type, des blocs INTERFACE. L’instruction CONTAINS indique la présence d’une ou plusieurs procédures.
Exemple II.1
PROGRAM ETOILE
USE DONNEES
IMPLICIT NONE
REAL :: r1, u1, T1
r1 = 1.e-3 ; u1 = 45000. ; T1 = 55635.
r1 = G * u1 * T1
PRINT*, »r1 vaut « , r1
END PROGRAM ETOILE

Les procédures externes

Une procédure externe est appelée depuis une autre unité de programme. Elle a une forme similaire à celle du programme principal, tant du point de vue de sa syntaxe que de son exécution. elle prend place On en distingue deux sortes : les sous-programmes et les fonctions. De plus, on distingue des procédures globales, contenues dans un module et utilisables par l’ensemble des autres unités de programme, des procédures internes, contenues dans une procédure globale et utilisables uniquement par leur hôte.
a) Les sous-programmes
Les sous-programmes, définis par le mot-clé SUBROUTINE, définissent une action au moyen de toutes les instructions du langage, dont l’appel prend lui-même la forme et l’apparence d’une instruction du langage. La syntaxe générale d’un sous-programme est la suivante :
SUBROUTINE nom_du_sous-programme [(arguments)] [instructions de spécification] [instructions exécutables]
[CONTAINS
[procédures internes]]
END SUBROUTINE [nom_du_sous-programme]
Les sous-programmes sont appelées, depuis une autre procédure (ou programme principal), avec l’instruction CALL nom_du_sous-programme [(arguments)].
b) Les fonctions
Les fonctions, définis par le mot-clé FUNCTION, calculent une valeur au moyen de toutes les instructions du langage, dont l’appel prend place au sein d’une expression. La syntaxe générale d’une fonction est la suivante :
[TYPE] FUNCTION nom_de_la_fontion (arguments) [instructions de spécification] [instructions exécutables]
[CONTAINS
[procédures internes]]
END FUNCTION [nom_de_la_fonction]
Les fonctions sont appelées directement à l’aide de leur nom propre et de leurs arguments, depuis une autre procédure (ou programme principal). On peut déclarer leur type avant l’instruction FUNCTION.
Exemple II.2
SUBROUTINE LOCATE (rr, TT, m, n, hmn)
IMPLICIT NONE
REAL, INTENT(IN) :: rr, TT
INTEGER, INTENT(OUT) :: m, n
REAL, OPTIONAL, DIMENSION(4), INTENT(OUT) :: hmn
REAL:: hm, hn, hm1, hn1, Vol
m = 1 ; n = 1
DO
…
m = m + 1
n = n + 1
END DO
IF (PRESENT(hmn)) THEN
! Calcul des poids pour l’interpolation des donnees. hm = TT – TeV(m) ; hm1 = TeV(m+1) – TT
hn = rr – rho(n) ; hn1 = rho(n+1) – rr Vol = (hm + hm1) * (hn + hn1)
hmn(1) = hm * hn / Vol
hmn(2) = hm1 * hn / Vol
hmn(3) = hm * hn1 / Vol
hmn(4) = hm1 * hn1 / Vol
END IF
END SUBROUTINE LOCATE
Exemple II.3
REAL FUNCTION ZMOY (rr, TT)
IMPLICIT NONE
REAL, INTENT(IN) :: rr, TT
CALL LOCATE (rr, TT, m, n, hmn)
zmoy = zbar(m,n) * hmn(4) + zbar(m+1,n) * hmn(3) &
+ zbar(m,n+1) * hmn(2) + zbar(m+1,n+1) * hmn(1) zmoy = 1. + zmoy
END FUNCTION ZMOY
c) Les procédures récursives
Dans certains cas particuliers, on a besoin qu’une procédure puisse s’appeler elle-même. D’ordinaire, cette structure de programmation est impossible. C’est pourquoi, il faut tout d’abord avertir le compilateur de ce mode de fonctionnement : on utilise l’attribut RECURSIVE devant le nom de la procédure, qu’elle soit un sous-programme ou bien une fonction. Attention toutefois au temps de calcul, qui peut devenir prohibitif, lors de plusieurs appels récursifs successifs !
Syntaxe générale :
recursive subroutine nom_proc (list_arg)
recursive function nom_proc (list_arg) result (nom_res)
Remarque : dans le cas d’une fonction, on est obligé d’utiliser un nom de résultat différent du nom de la fonction, défini à l’aide du mot clé RESULT.
Les fonctions récursives peuvent être, par exemple, très utiles pour traiter des suites mathématiques, qui par définition, sont construites en référence au rang inférieur. Ainsi pour calculer la suite arithmétique :
u1 = 1; u2 = 3 ; un = 3un−1 − un−2 n ≥ 3
Exemple II.4
RECURSIVE FUNCTION SUITE (n) RESULT (u)
INTEGER, INTENT (IN) :: n
INTEGER :: u
SELECT CASE (n)
CASE (1)
u = 1
CASE (2)
u = 3
CASE DEFAULT
u = 3 * suite (n-1) – suite (n-2)
END SELECT
END FUNCTION SUITE
Remarque : Le mot-clé RESULT peut être utilisé dans toutes les fonctions pour définir le nom du résultat, qu’elles soient récursives ou non. Le type du résultat est toujours celui de la fonction.

Les modules

Un module est une unité de compilation qui a pour fonction de mettre à disposition, aux autres unités de compilation, des ressources logicielles comme des constantes, des variables, des types et des procédures. C’est une abstraction des données et des procédures qu’il encapsule, réalisant ainsi une boîte noire pour l’utilisateur et favorisant la maintenance des applications. Le module n’est pas exécutable, il n’y a que le programme principal qui le soit. La forme générale d’un module est la suivante :
MODULE nom_du_module
[instructions de spécification]
[CONTAINS
[procédures globales]]
[procédures internes]]
END MODULE [nom_du_module]
Exemple II.5
MODULE DONNEES
IMPLICIT NONE
REAL, PARAMETER :: Rgaz = 8.314e7
CONTAINS
SUBROUTINE INIT (r1, u1, T1)
IMPLICIT NONE
REAL, INTENT(IN) :: r1, u1, T1
REAL :: gam, Mach
gam = 5./3.
! Mach = u1/Csound ; nombre de Mach Mach = u1 * sqrt(131/(gam*Rgaz*T1))
WRITE (6,*) « Le nombre de Mach est de « , Mach
END SUBROUTINE INIT
END MODULE DONNEES
a) Accès aux ressources d’un module
L’accès aux ressources d’un module se fait grâce à l’instruction use nom_module. Cette ligne d’instruction se place toujours en tête de l’unité utilisatrice, avant le bloc déclaratif et permet l’importation de l’intégralité du module dans cette unité de compilation.

I Historique
II Structure d’un programme et syntaxe
II.A Unités de Programme et procédures
II.A.1 Le programme principal
II.A.2 Les procédures externes
II.A.3 Les modules
II.B Format et Syntaxe
II.B.1 Le format
II.B.2 Les identificateurs et la syntaxe
II.B.3 Commentaires
II.B.4 Chaînes de caractères
II.C Les types et les déclarations
II.D Autres types
II.E Les fonctions intrinsèques
III Structures de contrôle
III.A Le choix avec IF
III.B Le choix avec SELECT CASE
III.C Le choix avec WHERE
III.D La boucle DO
III.E Le schéma FORALL
IV Les tableaux
IV.A Gestion mémoire des tableaux
IV.A.1 L’allocation statique
IV.A.2 L’allocation dynamique
IV.B La manipulation des tableaux
IV.C Les fonctions intrinsèques sur les tableaux
V Les pointeurs
V.A Introduction
V.A.1 Définition :
V.A.2 Déclaration d’un pointeur et d’une cible
V.B État d’un pointeur
V.C L’allocation dynamique
VI Contrôle de visibilité
VI.A Les ressources privées et publiques
VI.A.2 les types dérivés semi-privés
VI.A.3 Restriction de l’instruction USE
VII Contrôle de cohérence
VII.A Les arguments de procédure
VII.B Interface de procédure
VII.C Interface générique
VII.D Surcharge et création d’opérateurs
VIII Les entrées / sorties
VIII.A Instructions générales
VIII.A.1 Description des paramètres de lecture / écriture
VIII.B Ouverture de fichiers
VIII.B.1 Description des paramètres d’ouverture
VIII.C L’instruction inquire
VIII.C.2 Par liste de sortie
VIII.D L’instruction namelist
IX ANNEXE
IX.A Quelques fonctions intrinsèques
IX.E Bibliographie