Discussion :

[shadock0]

Bonjour,

Voilà, je m'explique: j'ai besoin de définir une fonction func. Seulement cette fonction ne devra pas faire la même chose selon le paramètre.

ce que je veux dire c'est que selon le choix de l'utilisateur dans le fichier de paramètre, la fonction pourra faire une chose ou bien une autre...

Le nombre et les possibilité de paramètres utilisables par l'utilisateurs peut changer. Je ne veut donc pas écrire 10 fonctions func1, func2, etc... evec des tests et être obligé de recommencer si tôt que les choix de paramètres changent.

existe-t-il une autre solution que mettre un grand nombre de if ou de case DANS la fonction ce qui risrque de la ralentir (car elle pourra être appellé de nombreuses fois.

Ce que j'aimerais c'est définir une fois pour toute la fonction au début du programe et ensuite ne plus faire le test pour économiser du temps de calcul...

Est-ce possible en fortran ? d'utiliser une fonction un peu comme une "variable" en y mettant différent types de calculs à faire selon le besoin ?

Je ne sais pas si j'ai été très clair...

Demandez moi si vous n'avez pas bien compris...

merci beaucoup en tout cas...

[bobbyboy]

Bonjour,

je vois deux solutions :

1) Utiliser des arguments optionnels. Mais je trouve ça peu pratique si tu as beaucoup de cas à traiter. Tu es obligé de mettre des " IF PRESENT ..." ce qui revient presque à ce que tu propose :

mettre un grand nombre de if ou de case DANS la fonction ce qui risrque de la ralentir

2) Utiliser la surcharge de fonction qui me parrait être la solution la plus élégante. Ca t'oblige à écrire plusieurs fonction F1 , F2 ... (donc à priori ce que tu voulais éviter) mais tu les regroupe sous une seule interface F_GLOBAL. Ensuite, dans le programme, en appellant F_GLOBAL avec des types et des nombres d'arguments différents, le programme choisi lui-meme la fonction à utiliser. Ce qui t'affranchi de la syntaxe lourde avec des IF ...

Plus clairement sur l'exemple suivant, la fonction "f_glob" fait :

- si les arguments sont 2 réels (x,y) : retourne x+y
- si les arguments sont 3 réels (x,y,z) : retourne x+y-z
- si les arguments sont 2 chaines de caractères (c1,c2) : retourne la chaine concaténée

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
program test
implicit none
 
! --------------------------------
 
interface f_glob
 
   fonction f1(x,y)         ! Interface de la 1ère fonction
      real(kind=8) :: f1 , x , y
   end
 
   fonction f2(x,y,z)       ! Interface de la 2eme fonction
      real(kind=8) :: f2 , x , y , z
   end
 
   fonction f3(c1,c2)       ! Interface de la 3ème fonction
      character*20 :: f3
      character*10 :: c1 , c2
   end
 
end interface
 
! --------------------------------
 
real(kind=8) :: reel1 , reel2 , reel3
character*10 :: char1 , char2
 
reel1 = 1.0
reel2 = 2.0
reel3 = 3.0
 
char1 = "bonjour"
char2 = "a tous"
 
write(*,*) f_glob(reel1,reel2)          ! le programme appellera f1
write(*,*) f_glob(reel1,reel2,reel3)    ! le programme appellera f2
write(*,*) f_glob(char1,char2)          ! le programme appellera f3
 
end program test
 
! --------------------------------
 
fonction f1(x,y)
   real(kind=8) :: f1 , x , y
   f1 = x + y
   return
end
 
fonction f2(x,y,z)
   real(kind=8) :: f2 , x , y , z
   f2 = x + y - z
end
 
fonction f3(c1,c2)
   character*20 :: f3
   character*10 :: c1 , c2
   f3 = trim(c1) // " " // trim(c2)
   return
end

Tous ça sans un IF, ce qui rend la syntaxe assez claire. Tu peux aussi bien surcharger des fonction que des subroutines de la même manière. De plus, cette façon de faire s'accorde bien si tu décomposes ton programme en modules :
- 1 module "interface" (pour ne pas avoir le gros bloc interface au début du programme principal)
- 1 module "définition des fonctions"
- 1 programme principal

Bien sur, le compilateur renvoit une erreur si l'interface contient 2 fonctions avec le même type et le même nombre d'argument. Au quel cas, le programme ne sait pas laquelle des deux choisir. Cette interface là renvoi une erreur à la compilation :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
interface f_glob
 
   fonction f1(x1,y1)         ! Interface de la 1ère fonction
      real(kind=8) :: f1 , x1 , y1
   end
 
   fonction f2(x2,y2)         ! Interface de la 2eme fonction
      real(kind=8) :: f2 , x2 , y2
   end
 
end interface

[shadock0]

oki, ça a l'air vraiment bien, je vais essayer ça !

Par contre, est-ce lorsque je fais cette surcharge, et que j'appel la fonction "interface" il fait un test à chaque fois ?

Parce que comme je fais du monte carlo et qu'il va appeller la fonction un bon milliard de fois, si il fait le test à chaque fois ca risque de ralentir.

j'aimerais que la fonction soit sélectionnée une bonne fois pour toute dès le début du programme.

est-ce possible ?

[Sylvain Bergeron]

La résolution (?) de la fonction effective découlant d'une interface est effectuée à la compilation. Si ça correspond à ton besoin, le résultat sera très efficace.

Si le choix de la fonction découle de données fournies par l'usager, cette technique n'est d'aucune utilité, puisque les données ne vont pas modifier le code source. Si c'est ta situation, tu devrais utiliser un case comme sélecteur, c'est plus efficace que des if imbriqués. De plus, si tu un compilateur Fortran 2003 (ou plus), tu pourrais utiliser les function pointers pour faire la résolution une fois seulement au début.

[Sylvain Bergeron]

J'oubliais...

Il y a une solution vieille comme le monde, en fait vieille comme Fortran IV. Toutes les librairies classiques (ex: Lapack) sont faites comme ça.

Il s'agit de déplacer la partie Monte-Carlo dans une routine et de passer la bonne fonction à cette routine comme paramètre (et elle la reçoit comme external) :

Code :

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

1
2
3
4
5
6
7
 
select case(NumFonction)
case(1); call MonteCarlo(a,b,c,...,Fonction1,...)
case(2); call MonteCarlo(a,b,c,...,Fonction2,...)
case(3); call MonteCarlo(a,b,c,...,Fonction3,...)
case(4); call MonteCarlo(a,b,c,...,Fonction4,...)
case(5); call MonteCarlo(a,b,c,...,Fonction5,...)