Discussion :

[Schopenhauer]

Bonjour,

Je débute la programmation en Fortran.

J'aurais voulus avoir votre avis sur ce code, notament au niveau de l'allocation dynamique,
j'aurais voulu savoir si mon code était "saint" au niveau de fuite de mémoire éventuelle.

Il s'agit d'un petit test sur la multiplication de deux matrices.

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
program essai
 
implicit none
 
real, dimension(1:3,1:3) :: A
real, dimension(1:3,1:3) :: B
real, dimension(:,:), allocatable :: C
 
integer :: i,j
 
A(1,1) = 1.0
A(1,2) = 2.0
A(1,3) = 3.0
A(2,1) = 4.0
A(2,2) = 1.0
A(2,3) = 2.0
A(3,1) = 3.0
A(3,2) = 4.0
A(3,3) = 5.0
 
B(1,1) = 1.0
B(1,2) = 2.0
B(1,3) = 3.0
B(2,1) = 4.0
B(2,2) = 1.0
B(2,3) = 2.0
B(3,1) = 3.0
B(3,2) = 4.0
B(3,3) = 5.0
 
 
 
call Produit_M(A,B,3,3,3,3,C)
 
do i=1, 3
    do j=1, 3
        print*,C(i,j)
    end do
    print*,''
end do
 
deallocate(C)
 
contains
 
!!!CREER UNE MATRICE EN ALLOCATION DYNAMIQUE!!!
!!!EN ARGUMENT : NOM DE LA MATRICE, ET DIMENSIONS!!!
 
subroutine Creer_matrice(A,nA,mA)
 
real, dimension(:,:),allocatable, intent(out) :: A
integer, intent(in) :: nA, mA
 
allocate(A(1:nA,1:mA))
 
end subroutine Creer_matrice
 
 
!!!                      SUBROUTINE DE PRODUIT DE DEUX MATRICES                !!!
!!!EN ARGUMENTS : MATRICE A, MATRICE B, DIM DE A DIM DE B, MATRICE RES RESULTAT !!!
 
subroutine Produit_M(A,B,nA,mA,nB,mB,Res)
 
implicit none
 
real, dimension(1:nA,1:mA), intent(in) :: A
real, dimension(1:nB,1:mB), intent(in) :: B
real,  dimension(:,:), allocatable, intent(out) :: Res
 
integer, intent(in) :: nA,mA,nB,mB
integer :: i,j,k
 
test_comp: if (mA == nB) then
 
               call Creer_matrice(Res,nA,mB)
 
                   do j=1, mB
                       do i=1, nA
                           do k=1,mA
                               Res(i,j) = Res(i,j) + A(i,k)*B(k,j)
                            end do
                        end do
                    end do
             else
                print*,'MATRICES INCOMPATIBLES !'
 
            end if test_comp
 
end subroutine Produit_M
 
end program essai

[bobbyboy]

Bonjour,
as tu testé ce programme?
J'ai eu des problèmes avec l'allocation dynamique à l'interieur de routines quand je ne déclarais pas explicitement les interfaces de ces routines.

[Sylvain Bergeron]

@bobbyboy

Puisque les routines sont incluses dans la section contains du programme, il y a automatiquement génération d'interfaces explicites par le compilateur. S'il y a problème, il n'est donc pas là.

@Schopenhauer

J'aurais déclaré comme suit la routine Produit_M :

Code :

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

1
2
3
4
5
subroutine Produit_M(A,B,Res)
   implicit none
   real, dimension(:,:), intent(in) :: A
   real, dimension(:,:), intent(in) :: B
   real, dimension(:,:), allocatable, intent(out) :: Res

En fait, j'aurais déclaré comme suit parce que je trouve « inélégant » le dimension :

Code :

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

1
2
3
4
5
subroutine Produit_M(A,B,Res)
   implicit none
   real, intent(in) :: A(:,:)
   real, intent(in) :: B(:,:)
   real, allocatable, intent(out) :: Res(:,:)

De là, tu peux utiliser les fonctions size, lbound ou ubound pour retrouver les bornes et dimensions de A et B.

Pour l'allocation de Res, je n'aurais pas utilisé de routine, à moins que l'allocation exige plusieurs lignes d'initialisation de la structure créée. Je trouve que c'est inutile s'il n'y a qu'une simple allocation, et la gestion des erreur est alors plus lourde (test dans la routine d'allocation, retour d'un code d'erreur, retest suite au call, ...).

[Sylvain Bergeron]

@Schopenhauer

Pour revenir à ta question sur les pertes de mémoire : Généralement, les problèmes de mémoire viennent des pointeurs et non des allocatables. Comme on ne peut pas allouer un allocatable déjà alloué, et que le compilateur désalloue l'espace d'allocatables lorsqu'il détruit les variables, il est difficile de perdre de la mémoire. À l'inverse, la mémoire attribuée aux pointeurs n'est jamais désallouée automatiquement, et il est possible de réallouer un pointeur déjà alloué...

[Schopenhauer]

Bonjour,

Merci pour vos réponses.

Pour l'allocation de Res, je n'aurais pas utilisé de routine, à moins que l'allocation exige plusieurs lignes d'initialisation de la structure créée. Je trouve que c'est inutile s'il n'y a qu'une simple allocation, et la gestion des erreur est alors plus lourde (test dans la routine d'allocation, retour d'un code d'erreur, retest suite au call, ...).

J'en suis arrivé à la même conclusion, j'ai donc abandonné cette idée je n'étais pas à 2 lignes de code près . J'avais déjà réalisé ce code il y a un moment en C avec des pointeurs et on m'avais conseillé de creer ce genre de 'fonction' création. Mais ici c'est vrais que c'est inutile.

J'ai utilisé les modules pour avoir un emplois plus facile de ces routines.

J'ai de plus écrit une routine d'inversion de matrice de dimension quelconque, je tacherais de la posté pour avoir vos avis après avoir apporté les quelques modifs que vous m'avez conseillé et après l'avoir convenablement annotée.

Merci encore.