Discussion :

[Axel7594]

Bonjour,

Je suis étudiant en école d'ingénieur. J'ai pour projet de créer un programme me permettant d'inverser une matrice.
Cependant je suis coincé, c'est pourquoi je vous demande votre aide. En effet, a priori je crois avoir finis mon programme mais j'ai trois erreurs de compilation que je n'arrive pas à résoudre. Peux être que ce ne sont que de petites erreurs mais je débute en fortran.

Je vous remercie par avance de votre aide et vous joins en pièce jointe :
- mon fichier contenant mes procédures externes intitulé : tools.f90
- mon fichier contenant mon programme principale : main.f90
- ainsi qu'une capture écran de mes erreurs au terminal

En vous remerciant de votre aide

[__dardanos__]

Salut,
En FORTRAN, on faut déclarer les variables dans l'en-tête et pas dans le corps du programme :

Code :

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

1
2
3
4
5
6
7
program inversion_de_matrice
    implicit none
    integer :: choix, nbrlignecollone
    real, allocatable :: A(:,:)
    real :: det
    real, allocatable :: inv(:,:)
    ...

[Axel7594]

Merci beaucoup.

Je n'ai plus d'erreur de compilation c'est déjà bien
Malheureusement quand je choisit les deux premiers cas de mon programme j'ai une erreur de segmentation (cf capture écran terminal en pièce jointe).
Avez vous une idée de la cause de ce problème?
Peux être que c'est un problème d'allouement de la mémoire mais je ne comprend pas encore bien cette notion.

Merci d'avance

[LittleOwl]

Bonjour

L'interface de la subroutine Saisir déclarée dans le main n'est pas la même que celle déclarée dans le fichier tools.f90. D'autre part, j'ai rajouté les intentions des arguments dans les deux fichiers.

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
 
 
main.f90
 
interface
....
subroutine saisir(A, nbrlignecollone)
   integer, intent(in) :: nbrlignecollone
   real,dimension(:,:), allocatable, intent(out) :: A
 end subroutine saisir
...
end interface
 
tools.f90
....
subroutine saisir(A, nbrlignecollone)
 
  integer, intent(in) :: nbrlignecollone
  real,dimension(:,:), allocatable, intent(out) :: A
 
  integer :: i, j, pballocation
 
  ....
end subroutine saisir

Néanmoins, cette seule correction ne suffit pas pour que votre code fonctionne correctement. En effet, l'utilisation d'un tableau dynamique se justifie pour la subroutine Saisir dans la mesure où elle sert à initialiser une matrice dont la dimension n'est connue qu'au moment de l'éxécution.

Mais, la mémoire ayant été allouée à la matrice A dans la subroutine Saisir, le fait de la réallouer dans la function Déterminant provoque une erreur d'éxécution. L'argument de la fonction déterminant devrait être un tableau de profil générique plutôt qu'un tableau dynamique.

Code :

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

1
2
3
4
5
6
 
  real function determinant(A, nbrlignecollone)
 
   integer, intent(in) :: nbrlignecollone
   real, dimension(:,:), intent(in) :: A
....

Cette erreur doit être corrigée dans la plupart de vos subroutines et fonctions.

Cordialement.

[Axel7594]

Merci beaucoup!

J'ai déjà résolu quelques erreurs et l’exécution de mon programme commence à fonctionner.
En effet j'arrive à saisir la matrice et à l'afficher cependant j'ai des erreurs de segmentation par la suite dans les fonctions determinant et inverse.

En executant, je constate que la fonction determinant fonctionne avec une matrice triangulaire (pas de permutation de ligne à effectuer). De plus en utilisant l'instruction write en exécutant, j'en déduis que le problème doit surement venir de ma subroutine "permutation_ligne".

Effectivement, je constate que dans ma boucle lors de la première itération il n'y a pas de problème pour la subroutine "permutation_ligne" en revanche par la suite : "erreur de segmentation". Je pense que cela doit être un problème d'allocation de la mémoire.

Savez vous comment je peux résoudre ce problème? LittleOwl m'a parlé de tableaux de profil générique mais je n'ai jamais entendu parler de cela... (Est-ce des tableaux "simple", non dynamiques?)

Je joins en pièce jointe une archive contenant :
- mon fichier tools.f90 et main.f90
- des captures d'écran des fonctions determinant et inverse, de ma subroutine permutation_ligne ainsi que du terminal.

Je vous remercie par avance de l'aide que vous pourrai m'apporter.

Cordialement

[LittleOwl]

Bonjour

LittleOwl m'a parlé de tableaux de profil générique mais je n'ai jamais entendu parler de cela... (Est-ce des tableaux "simple", non dynamiques?)

Désolé, je pense que l'appellation exacte n'est pas "tableau de profil générique" mais "tableau de profil implicite". Brièvement, ce type de déclaration est utile lorsqu'on passe en argument d'une subroutine ou d'une fonction un tableau de rang fixe, mais dont la taille peut varier d'un appel à l'autre de la fonction. La primitive size permet de connaitre la taille du tableau passé en argument selon ses différentes dimensions. Ce ne sont pas des tableaux dynamiques. Les tableaux passés en argument doivent avoir été alloué en mémoire avant l'appel, soit au moment de leur déclaration (tableau statique), soit à travers la primitive allocate (tableau dynamique).

Il existe néanmoins une autre méthode permettant de gérer cette situation, qui consiste à passer en argument, à la fois le nom du tableau et sa taille dans ses différentes dimensions. C'est la méthode que vous avez adoptée dans la dernière version de votre programme. Par conséquent, ce n'est pas l'utilisation de tableau de profil implicite qui résoudra les problèmes de gestion de mémoire que vous rencontrez.

A titre d'exemple, vous trouverez ci-dessous une fonction qui calcul la trace d'une matrice carré nXn dont l'argument est déclaré comme un tableau implicite.

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
 
program trace
 
implicit none
 
real, dimension(9), parameter :: values = (/ 1, 2, 3, 1, 4, 9, 1, 8, 27 /)
integer, dimension(2), parameter :: profil2 = (/2, 2/)
integer, dimension(2), parameter :: profil3 = (/3, 3/)
 
real, dimension(2,2) :: A = reshape(values(1:4), profil2)
real, dimension(3,3) :: B = reshape(values, profil3)
 
integer :: i
 
call mprint(A)
print '("Tr(A) = ", g15.6)',tr(A)
 
print *
 
call mprint(B)
print '("Tr(B) = ", g15.6)',tr(B)
 
contains
 
real function tr(m)
 
real, dimension(:,:), intent(in) :: m ! Tableau de rang 2, de profil implicite
 
real :: s = 0
integer :: i, n
 
n = size(m,1)	! Taille de la matrice m selon la dimension 1
 
do i = 1, n
  s = s + m(i,i)
end do
 
tr = s
 
end function tr
 
subroutine mprint(m)
 
real, dimension(:,:), intent(in) :: m ! Tableau de rang 2, de profil implicite
 
integer :: n
 
n = size(m,1)	! Taille de la matrice m selon la dimension 1 (m est supposee carree)
do i = 1, n
 print *,m(i,:)
end do
 
end subroutine mprint
 
end program trace

Si vous souhaitez plus d'information sur les tableaux de profil implicite, vous pouvez consulter par exemple le Chapitre 7 de la référence "Delannoy, Programmer en F90", notamment les pp 161-165

Cordialement.