Discussion :

[sfiliste]

Bonjour,

J'ai une question concernant la gestion des tableaux en sortie de fonction en FORTRAN90.

Mon but (c'est un cas d'école) est d'écrire une fonction qui prend en entrée deux tableaux T1 et T2 (de même dimension) et retourne un tableau (de dimension inf. ou égale à la taille de T1) des valeurs communes placées au même endroit

Exemple :

T1 = (8,2,3,4,5,1)
T2 = (8,3,2,5,5,7)

f(T1,T2) = (8,5)


Comment puis je créer une fonction qui renvoie un tableau sans connaitre la longueur de ce tableau à l'appel de cette fonction?

Pourriez vous m'aider?
Merci

[Grame]

Bonjour


Tu sais que ta fonction retourne un tableau de taille inférieure ou égale aux tableaux entrants. Donc tu le déclares commes les autres.

Exemple simple :

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
program f
  implicit none
  integer, dimension(6) :: t1, t2, t3
  integer :: dim
 
  data t1 / 8,2,3,4,5,1 /
  data t2 / 8,3,2,5,5,7 /
 
! Tu n'es pas obligé de récupérer dim, c'est toi qui voit si tu en as besoin
  call cf (t1, t2, t3, dim)
  print *, t3(1), t3(2), dim
 
end program f
 
subroutine cf (t1, t2, t3, dim)
  implicit none
  integer, dimension(*), intent(in) :: t1, t2
  integer, dimension(*), intent(out) :: t3
  integer, intent(out) :: dim
 
  t3(1) = 8
  t3(2) = 5
  dim = 2
 
end subroutine cf

C'est juste une base de travail, à toi de continuer.

[sfiliste]

Merci de ta réponse.

Mais mes tableaux t1, t2 sont de taille variable : ils sont déclarés en

integer, dimension(, allocatable :: t1, t2

C'est après un calcul que je connais leur longueur j et que je fais un

allocate(t1(1:j), t2(1:j)

et que je remplis les tableaux.

Et j'aimerais que le tableau t3 soit de bonne taille.

Merci

[Sylvain Bergeron]

Comme c'est un travail de classe, je ne vais pas te donner la réponse, mais comme tu as l'honnêteté de nous le dire, voici une piste pour la solution la plus "flyée" à ce problème : Tu dois dimensionner ton tableau de sortie avec une fonction "pure" utilisant les arguments "intent in" de ta fonction principale. Pour plus d'indice : recherche Fortran + "James Van Buskirk". Il a déjà publié la solution à un problème très semblable...

[sfiliste]

Bonjour,

Je me suis mal exprimé par "cas d'école"! Je voulais dire que le but de ce programme était de manipuler des tableaux pour comprendre, sans vouloir dire que j'étais étudiant (j'ai malheureusement passé l'âge!)

Je pense comprendre l'idée de dimensionner mon tableau par une nouvelle fonction mais pourriez vous m'en dire un peu plus?

Merci à vous

[Sylvain Bergeron]

Cas général :

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
pure integer function NbPareil(a,b)
   integer, intent(in) :: a(:), b(:)
   integer k
   NbPareil = 0
   do k = 1, size(a)
      if (a(k) == b(k)) NbPareil = NbPareil + 1
   enddo
   end function
 
program Test
   implicit none
   integer T1(6)
   integer T2(6)
 
   T1 = [8,2,3,4,5,1]
   T2 = [8,3,2,5,5,7]
 
   print *, Pareil(T1,T2)
 
contains
 
   function Pareil(U,V) result(R)
      integer, intent(in) :: U(:),V(:)
      interface
         pure integer function NbPareil(a,b)
            integer, intent(in) :: a(:), b(:)
            end function
      end interface
      integer             :: R(NbPareil(U,V))
      R = pack(U,U==V)
      end function Pareil
 
end program

La technique, c'est qu'une variable peut être dimensionnée par une expression faisant référence uniquement à des fonctions pures ou des fonctions informatives (size, count, ...) du langage (cette limite est relâchée en F2003). En pratique, on fait donc 2 fois le travail : une première fois pour calculer le nombre d'élément requis dans une fonction pure, et une deuxième fois pour traiter effectivement. La technique aurait été inventée par James Van Buskirk.

Malheureusement, le compilateur que j'ai sous la main (Intel 9.1) est un peu vieux et ne supporte pas ce programme : il termine sur un ICE. Mais il n'y a pas d'erreur de syntaxe. Si quelqu'un pouvait l'essayer avec gfortran ou Intel 10, ce serait gentil.

Une version très simplifiée, mais qui fonctionne :

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
program Test
   implicit none
   integer T1(6)
   integer T2(6)
 
   T1 = [8,2,3,4,5,1]
   T2 = [8,3,2,5,5,7]
 
   print *, Pareil(T1,T2)
 
contains
 
   function Pareil(U,V) result(R)
      integer, intent(in) :: U(:),V(:)
      integer             :: R(count(U == V))
      R = pack(U,U==V)
      end function Pareil
 
end program

Cette version illustre cependant mal la possibilité introduite par la première méthode. Elle est possible parce qu'une fonction intrinsèque du langage permet de calculer directement le nombre d'élément requis.