Discussion :

[ClaireA]

Coucou à tous!
Je suis entrain de plancher sur de la factorisation LU. J'ai écrit un programme qui, selon la valeur d'une variable v me permet de factoriser une matrice A en LU (qd v=1), résoudre A.X=B (qd v=2), et qui calcule le produit matriciel de A.Y (qd v=3).
Pour cela j'ai créé une subroutine factolu qui a en paramètre v, et un petit menu dans mon programme principal qui demande à l'utilisateur de choisir ce qu'il veut faire. Ce menu apparait en boucle sauf si l'utilisateur choisit v=0 (ce qui quitte le programme). En testant, il n'y a aucun souci pour la factorisation, aucun problème non plus pour la multiplication matricielle. Par contre, pour résoudre A.X=B (avec X un vecteur inconnu donc), on a besoin de la factorisation LU, et visiblement (avec quelques tests) je me suis rendue compte que même en faisant v=1 d'abord, puis v=2, les matrices L et U ne sont pas gardées en mémoire. Comment faire? D'après l'énoncé de mon exercice, je ne dois pas les passer en paramètre de ma subroutine factolu.

Je demande surtout une explication pur comprendre. Merci beaucoup!

[genteur slayer]

dans un premier temps, il est peu recommandé de faire une fonction "qui fait tout" et avec un paramètreou alors de la faire appelé des fonction spécifique:

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
 
subroutine general(v)
  interger,intent(in)::v
if (v==1) call facto
if (v==2) call solve
if (v==3) call prod
end subroutine general
 
subroutine facto
 !la sub qui fait la factorisation
end subroutine facto
 
subroutine solve
 !la sub qui résout A.X=B
end subroutine solve
 
subroutine Prod
 !la sub qui fait le produit A.Y
end subroutine prod

si ton prog ne doit pas avoir de paramètres A,L,U etc...
alors il te faut des variables globale, en fortran90 l'utilisation des module est recommandé:

Code :

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

1
2
3
4
5
6
 
Module variables
 implicit none
  real(kind=8),dimession(80,80) :: A,L,U 
  ! ...etc...
end module variables

que tu utilise dans tes routine en faisant simplement:

Code :

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

1
2
3
4
5
6
 
subroutine facto
  use variables
  ! blablabla
  L=...blablabla
end subroutine facto

ainsi tes variables sont bien stokée et sont conservée à la fin de ta subroutine.

en gros: la différence entre variable local et variable globale:

lorsque tu es dans une routine ou fonction tu déclare des variables, celle-ci sont détruite à la fin de l'éxécution de ta routine ce sont les variable local
les variable globale quant à elle sont définies avant la fonction et ont une certaine valeure, la routine les modifie et lorsque routine finie, les variables existent toujours, et ont la valeur modifiée

un moyen est de les passer par paramètre, mais comme cela t'est interdit, il faut que ta fonction aille chercher l'information là où elle est stokée donc aller chercher les variables globales

[ClaireA]

Ok je vois. Et je peux définir L et U en allocatable dans module variables ?
Il faudra que je les allocate dans le programme principal ou dans la subroutine ?

[genteur slayer]

oui, tu peux mettre des allocatable dans le module aucun soucis!!!

ensuite pour les allouer, un moyen élégantest de mettre des routines d'allocation dans le module, exemple:

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
 
module tableaux
implicit none
real(kind=8),dimension(:,:),allocatable :: A
integer Nx,Ny
 
interface
  subroutine allocateTab(maillex,mailley)
    implicit none
    integer,intent(in) :: maillex,mailleY
  end subroutine allocateTab
 
  subroutine deallocatetab
    implicit none
  end subroutine deallocatetab
end interface
 
end module tableaux
 
 subroutine allocateTab(maillex,mailley)
  use tableaux,only : Nx,Ny,A
  implicit none
  integer,intent(in) :: maillex,mailleY
!
  Nx=MailleX
  Ny=MailleY
  allocate(A(Nx,Ny))
!
return
!
end subroutine allocateTab
 
subroutine deallocatetab
  use tableaux,only :A
  implicit none
!
  deallocate(A)
!
return
end subroutine deallocatetab

dans cette construction, la taille du tableau est elle aussi stockée dans le module, mais c'est facultatif!!! ensuite pour le moment où l'alloué, et bien il suffit de le faire juste avant la première utilisation (que ce soit dans une routine ou le prog principal...

cependant il faut faire attention à ne pas faire un allocate sur un tableau déjà aloué (il y aura une erreur à l'éxécution, mais pas à la compilation)

par contre tu peux parfaitement au cours d'un programme allouer un tableau, l'utiliser, le désallouer puis l'allouer à nouveau (avec une taille différente par exemple) cependant la désallocation détruit toute les données qui s'y trouvaient car il n'y a aucune raison pour que le système t'alloue le même emplacement mémoire...

[FR119492]

Salut!
Au lieu de te fatiguer, tu vas sur le site www.netlib.org, tu cherches la librairie LinPack, et dans celle-ci, les routines DGECO, DGEFA et DGESL.
Jean-Marc Blanc