Discussion :

[Casimirs]

Bonjour à tous,

J'ai un petit soucis en Fortran pour donner une valeur particulière à des variables définis dans un module. Voici les scripts (module et programme principal) écrits dans deux fichiers différents (voir plus loin). Comme vous pouvez le constater, je cherche à afficher à l'écran la somme x + y + z (qui doit valoir 3000 d'après les valeurs données à x,y et z). Le problème est que ça m'affiche "somme = 1000" !! Comment imposer les valeurs de x, y et z (apparemment x est bien assignée mais pas y et z) à partir du programme principal pour que les variables x, y et z utilisées dans le module prennent bien ces valeurs ?
Je précise que la fonction S(x) doit rester une fonction de la variable x seulement et qu'aucun autre argument ne doit figurer dans la sous-routine ! Pour la compilation, j'utilise les commandes
>> gfortran fonction.f90 test.f90 puis >>./a.out

Je vous remercie pour votre aide

Antoine

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
!------------------------------
! Le module (fonction.f90)
!------------------------------
module fonction
 
contains
function S(x)
implicit none
real*8 :: S
real*8, intent(in) :: x
real*8 :: y, z
 
S = x+y+z
 
end function S
 
end module fonction
 
!-----------------------------------
! le programme principal (test.f90)
!-----------------------------------
program somme
use fonction
 
implicit none
real*8 :: x = 1000
real*8 :: y = 1000
real*8 :: z = 1000
 
call moduletest
 
contains
subroutine moduletest
print*, 'somme = ', S(x)
end subroutine 
 
end program somme

[Grame]

Bonjour

Comment imposer les valeurs de x, y et z (apparemment x est bien assignée mais pas y et z) à partir du programme principal pour que les variables x, y et z utilisées dans le module prennent bien ces valeurs ?
Je précise que la fonction S(x) doit rester une fonction de la variable x seulement et qu'aucun autre argument ne doit figurer dans la sous-routine !

y et z n'étant pas passés en arguments, et tu ne veux pas le faire, la fonction S ne peut donc pas connaitre leur valeur.

Il existe (au moins) 2 solutions selon que x et y sont des paramètres ou des variables.
Si ce sont des paramètres, il suffit de créer un petit module de definitions.

N: l'écriture real*8 est obsolete, il faut écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
  real (kind=8) :: ..

De même le module moduletest dans le programme principal ne sert à rien.

Le code devient donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
!------------------------------ 
! Le Module definitions 
!------------------------------ 
module definitions
 
  implicit none
  real (kind=8), parameter :: y = 1000.0
  real (kind=8), parameter :: z = 1000.0
end module definitions
 
!------------------------------
! Le module (fonction.f90)
!------------------------------
module fonction
 
  contains
 
  function S(x)
  use definitions
  implicit none
  real (kind=8) :: S
  real (kind=8),intent(in) :: x
 
  S = x+y+z
 
end function S
 
end module fonction
!-----------------------------------
! le programme principal (test.f90)
!-----------------------------------
program somme
  use definitions
  use fonction
  implicit none
  real (kind=8) :: x = 1000.0
 
  print*, 'somme = ', S(x)
 
end program somme

à compiler par :
gfortran definitions.f90 fonction.f90 test.f90

./a.out renvoie :
somme = 3000.0000000000000

Par contre si y et z sont des variables, je ne vois comment faire autrement qu'utiliser des common mais je ne suis pas très familier des common dans des modules.

[Sylvain Bergeron]

La solution consiste à rendre les variables y et z publics au module. Le programme qui utilise ce moule verra alors les variables et pourra y assigner des valeurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
!------------------------------
! Le module (fonction.f90)
!------------------------------
module fonction
 
   real*8 :: y, z
 
contains
   function S(x)
      implicit none
      real*8 :: S
      real*8, intent(in) :: x
 
      S = x+y+z
 
   end function S
 
end module fonction
 
!-----------------------------------
! le programme principal (test.f90)
!-----------------------------------
program somme
use fonction
 
implicit none
real*8 :: x = 1000
!real*8 :: y = 1000 le fait de déclarer des variables y et z masquerait
!real*8 :: z = 1000 les variables y et z du module fonction
 
y = 1000 ! y et z du module fonction
z = 1000
call moduletest
 
contains
subroutine moduletest
print*, 'somme = ', S(x)
end subroutine 
 
end program somme

[Casimirs]

Super !

Merci à vous deux !!

A +

[Ehouarn]

Bonjour,

Pour la compilation, j'utilise les commandes
>> gfortran fonction.f90 test.f90 puis >>./a.out

C'est hélas la façon la moins pertinente de faire...
Quand on développe du code, on utilise toujours les options de compilations permettant de débusquer les erreurs.
Si tu avais pris la bonne habitude de faire par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
gfortran -O2 -Wall -fbounds-check -ffpe-trap=invalid,zero,overflow fonction.f90 test.f90

Tu aurais d'emblée obtenu des messages d'erreur au sujet des variables y et z utilisées bien que non-assignées dans la fonction s.

Bonne continuation