Modules et common

Bonjour

Voilà mon problème j'utilise souvent les common pour avoir des blocs de variables en commun (par exemple une série de parametres) que je colle dans mes différentes subroutine pour m'en servir un peu ou je veux.

Le problème c'est que si je veux utiliser les common avec implicit none il faut que je déclare deux fois les variables. Une fois dans le common et une autre fois en disant leur type ect ...

Du coup j'avais envie d'essayer de faire ça avec un module, seulement je sais pas faire et je trouve pas d'exemple simple d'utilisation de module.

Voici un exemple :

Code:

---

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

Program implicit none integer::nstlim,nptr,ntwr,ntwx,nmropt common /npar/ nstlim,nptr,ntwr,ntwx,nmropt   .....   end   subroutine plop implicit none integer::nstlim,nptr,ntwr,ntwx,nmropt common /npar/ nstlim,nptr,ntwr,ntwx,nmropt ... end

---

Je voudrais remplacer le common par un module ...

Je voudrais aussi savoir si dans certaines subroutine je peux déclarer que les variables sont des parametres (non modifiables) et dans d'autre qu'ils soient modifiables.

Merci

Bonjour,

Pour ce qui est de l'utilisation (à l'ancienne) de variables en 'common', je proposerai plutôt de passer par un fichier externe qui est ensuite inclus dans le(s) routine(s) correspondante.
Par ex, tu crée le fichier 'common_data.inc':

Code:

---

1 2 3

integer::nstlim,nptr,ntwr,ntwx,nmropt common /npar/ nstlim,nptr,ntwr,ntwx,nmropt

---

et tes codes seraient alors de la forme:

Code:

---

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

Program implicit none include "common_data.inc"   .....   end   subroutine plop implicit none include "common_data.inc" ... end

---

Et ne pas oublier à la compilation d'indiquer au compilateur ou trouver le fichier 'common_data.inc' (généralement c'est l'option -Ichemin/vers/fichiers/a/inclure ; généralement pas nécessaire à préciser si le fichier à inclure est dans le même répertoire que le code).

Pour ce qui est d'utiliser un module au lien d'un 'common' la syntaxe serait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

module common_data ! module contenant les variables en commun implicit none integer::nstlim,nptr,ntwr,ntwx,nmropt end module common_data     program mon_super_programme use common_data implicit none ... end program mon_super_programme     routine ma_super_routine use common_data implicit none ... end routine ma_super_routine

---

Et pour répondre à ta dernière question, on peut utiliser les spécificateurs 'intent(in)' ou 'intent(out)' dans une subroutine pour spécifier si les arguments sont "en entrée" (donc ne devant pas être modifiés par la routine) ou en sortie.
Par exemple:

Code:

---

1 2 3 4 5 6 7 8

subroutine ma_routine(operation,donnee,resultat) implicit none integer,intent(in) :: operation ! valeur en entrée real,intent(in) :: donnee ! valeur en entrée real,intent(out) :: resultat ! valeur en sortie ... end subroutine ma_routine

---

Bonne continuation.

Le coup des intent in et out je connaissait mais je me demandais si je pouvais déclarer en parameter des variables d'un common ou d'un modules. Et en fait non car si je déclare un parameter il veut la valeur à la déclaration. Donc en fait si tu déclare un parameter tu le déclares pour tout le programme.

Merci pour la syntaxe des modules !

Juste une dernière question, est ce que les variables définies dans le modules doivent être redéclarée dans la routine ? et est ce que ça joue le role d'un common ? C'est à dire que les valeurs sont transmises aussi ?

Par exemple si j'initialise dans une routine les variables contenu dans le common, est ce qu'elle garde leurs valeurs dans les autres routines et dans le prog principal ? En fait est ce que les variables du modules sont locales ou globales ?

Oui, le fonctionnement avec les modules est le même qu'avec des common: les variables sont "partagées" par toutes les routines qui incluent le module, et de ce point de vue on peut dire qu'elles sont globales.

Si dans mon module j'initialise des valeurs, comme par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

MODULE parm implicit none ! les parametre AMBER integer::nstlim,ntpr,ntwr,ntwx,nmropt integer::irest,ntx,ig nstlim = 0 ntpr = 0 ntwr = 0 ntwx = 0 nmropt = 0 irest = 0 ntx = 0 ig = 0   ! nombre de pas dans les bouts AMBER integer,parameter::npas=5   ! les fichiers input/output character(len=100)::input,restrtin,top character(len=100)::output,restrtout,crd,dumpave END MODULE parm

---

Est ce que les valeurs vont reprendre la valeur 0 dés que je fais un use parm ?

La syntaxe n'est pas bonne, mais oui, les valeurs sont initialisées au chargement, donc disponibles dès le premier use.

La syntaxe : Tu peux donner une valeur initiale à la déclaration, comme par exemple :

Code:

---

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

MODULE parm implicit none ! les parametre AMBER integer :: nstlim = 0 ! documentation ... integer :: ntpr = 0 ! ... integer :: ntwr = 0 ! ... integer :: ntwx = 0 ! ... integer :: nmropt = 0 ! ... integer :: irest = 0 ! ... integer :: ntx = 0 ! ... integer :: ig = 0 ! ... ... END MODULE parm

---

Une méthode alternative consiste à ajouter une procédure d'initialisation dans le module :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

MODULE parm implicit none ! les parametre AMBER integer::nstlim,ntpr,ntwr,ntwx,nmropt integer::irest,ntx,ig   ! nombre de pas dans les bouts AMBER integer,parameter::npas=5   ! les fichiers input/output character(len=100)::input,restrtin,top character(len=100)::output,restrtout,crd,dumpave   contains   subroutine Initialise nstlim = 0 ntpr = 0 ntwr = 0 ntwx = 0 nmropt = 0 irest = 0 ntx = 0 ig = 0 end subroutine Initialise   END MODULE parm

---

Tu dois évidemment appeler la subroutine d'initialisation à la première occasion. Cette méthode est souvent requise quand les éléments à initialiser sont plus complexe (allocate, open, ...).

Euh j'ai pas tout compris 8O

Le coup de déclarer et d'initialiser en même temps => ok (en fait j'aime pas trop car quand yen a trop on y voit plus rien ^^ ) !

Ensuite tu dis que dés le premier use les variables auront la valeur que tu leur donne dans la déclaration (ici 0) dans le module. Mon problème c'est que la première fois que j'appelle use, je veux bien qu'elles aient la valeur 0. Mais dans la subroutine où j'appelle mon module je lis ces paramètres et les noms de fichier ... donc je veux pas qu'au retour dans le programme principal ou la prochaine fois que je fais use elles reprennent la valeur de départ .

Visiblement la subroutine initialise jouerait ce role là ?
Si je comprend bien cette subroutine est dans le module mais elle ne s'exécute uniquement si je fais un call initialise dans une sous programme ou programme principal dans lequel j'ai fais un use de mon module ? C'est ça ?

Citation:

---

Envoyé par Ladgalen

...tu dis que dés le premier use les variables auront la valeur que tu leur donne dans la déclaration (ici 0) dans le module. Mon problème c'est que la première fois que j'appelle use, je veux bien qu'elles aient la valeur 0. Mais dans la subroutine où j'appelle mon module je lis ces paramètres et les noms de fichier ... donc je veux pas qu'au retour dans le programme principal ou la prochaine fois que je fais use elles reprennent la valeur de départ ...

---

Je me suis de toute évidence mal exprimé. Les variables sont initialisées au chargement/lancement et sont donc initialisées dès que tu y fais référence. À partir de là, si tu change leurs valeurs, elles conserveront la nouvelle valeur. En résumé, ça fait exactement ce que tu veux.

Citation:

---

Envoyé par Ladgalen

Visiblement la subroutine initialise jouerait ce role là ?
Si je comprend bien cette subroutine est dans le module mais elle ne s'exécute uniquement si je fais un call initialise dans une sous programme ou programme principal dans lequel j'ai fais un use de mon module ? C'est ça ?

---

Exactement. L'idée des modules est de mettre les fonctions / subroutines associées aux variables du module dans le module (dans ce cas ci, Initialise). Tu pourrais ajouter les routines Lecture, Écriture, etc. Lorsque tu as à ajouter une variable par exemple, les modifications requises (déclaration, initialisation, lecture, écriture, ...) risquent d'être limitées au module.

Oki merci !!

Je n'arrive pas bien à saisir l'interet de mettre des subroutine/function dans les modules vues que de toute façon il faut les appeler dans le programme.

En fait dans un module je met des variables qui seront commune à plusieurs sous programme donc là je vois l'interet. Mais pour les subroutine/fonction, du moment qu'elles sont dans le même fichier ou qu'on les indiques au compilateur (ça je sais pas faire :p ) on peut les appeler dans n'importe quelle partie du programme ...

Tu n'aurais pas un exemple pour que je vois l'intéret ? Si les gens ont inventé ça c'est que ça doit servir !

Un module sert principalement à 3 choses (à moins que j'en oublie) :

• Définir des types de données
• Partager des variables à la place des commons
• Publier des interfaces automatiquement

Actuellement tu utilises un module en remplacement d'un common.

L'utilisation d'interface rend les programmes plus facile à déboguer simplement parce que le compilateur peut faire plus de validation par lui-même. En utilisant un module, la publication automatique des interfaces t'assure que les interfaces correspondent bien aux fonctions et routines, donc moins de risque d'erreur.

Dans un gros programme, l'avantage des modules vient à mon avis de l'association du premier et du troisième point. Par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

module ModuleDate implicit none   type TDate ... end type ...   interface operator (-) module procedure DateSub end interface   contains   function DateCreate(AA,MM,JJ) integer, intent(in) :: AA,MM,JJ type (TDate) :: DateCreate ...   function Aujourdhui() type (TDate) :: Aujourdhui ...   function Annee(Dt) type (TDate), intent(in) :: Dt integer :: Annee ...   function EstBisext(Dt) type (TDate), intent(in) :: Dt logical :: EstBisext ...   function DateSub(Dt1,Dt2) type (TDate), intent(in) :: Dt1,Dt2 integer :: DateSub ...   end module   program UseModuleDate   use ModuleDate implicit none   type (TDate) :: UneDate, UneAutreDate, EncoreUneDate, DtExec   DtExec = Aujourdhui()   UneDate = DateCreate(2008,05,28)   TempsEcoule = DtExec - UneDate ...

---

Comme tu peux voir dans cet exemple, il serait possible de créer l'ensemble des fonctions de manipulation de date de sorte que le reste du programme (les « clients » du module date) pourrait être indépendant de la représentation interne du type TDate (aa,mm,jj ? julien ? sérial à la Excel ?...). Une modification à TDate pourrait alors être limitée au module.