Discussion :

[ZRemi]

Bonjour,

Je voudrais savoir si il existe une fonction de Matlab optimisée afin d'utiliser les L et U de la décomposition du même nom pour résoudre des systèmes linéaires.

Je reformule : j'ai Ax = b pour plein de b différents. Donc je veux ne faire qu'une seule fois [L,U] = lu(A) et je veux réutiliser mes matrices L et U. (L'utilisation de \ est exclue car trop longue).

Merci,
RémiZ

[Jerome Briot]

[L,U] = lu(A)

Je ne comprends pas bien ton problème...

Quel est le problème avec la syntaxe ci-dessus ?

[FR119492]

Salut!

pour plein de b différents

Est-ce que tu les as simultanément ou successivement?
Jean-Marc Blanc

[ZRemi]

Merci pour vos réponses.

@Dut : Pour reformuler mon problème, voila ce que je fais, et qui fonctionne aujourd'hui :

Code :

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

1
2
3
4
5
6
 
A_inv = inv(A);
for i = 1:N
 b_i = f(i); // une fct qui depend de i
 x_i = A_inv*b_i
end

Et je voudrais quelque chose de plus rapide du style :

Code :

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

1
2
3
4
5
6
 
[L,U] = lu(A);
for i = 1:N
 b_i = f(i) // une fct qui depend de i
 // x_i solution de A x_i = b_i resolu grace a L et U
end

Je peux, pour la dernière étape (l.4), faire un code Matlab, mais il n'est pas aussi bien optimisé que la multiplication matricielle, et la première solution reste la meilleure car la mieux codée.

@Jean-Marc : Comme indiqué dans mon code, les b_i arrivent successivement, et non simultanément.

Bien à vous,
RémiZ

[FR119492]

Salut!
Essaie

Code :

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

1
2
3
4
5
[L,U] = lu(A);
for i = 1:N
  y_i=L\b_i;
  x_i=U\y_i;
end

Il y a ainsi deux résolutions de systèmes à la place d'une, mais la complexité est N^2 au lieu de N^3. Si la programmation interne de Matlab est bien optimisée, ce que je crois être le cas, pour des systèmes de grosse taille, ça devrait être plus rapide.
Jean-Marc Blanc

[ZRemi]

Et oui, j'avais essayé le code suivant :

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
 
N = 500;
A = rand(N,N);
B = rand(N,N);
X_inv = zeros(N,N);
X_LU = zeros(N,N);
 
%//-------------------//
%// Inversion bourrin //
%//-------------------//
tic
A_inv = inv(A);
for ii = 1:N
	X_inv(:,ii) = A_inv * B(:,ii);
end
toc
%//-------------------//
pause
%//---------------//
%// Inversion LU2 // OK lent
%//---------------//
tic
[LL,UU] = lu(A);
for ii = 1:N
	X_LU(:,ii) = UU \ ( LL \ B(:,ii) );
end
toc

La méthode "bourrin" est bien plus rapide, d'autant plus que N augmente. Il faut donc croire que pour cette fois, la programmation interne de Matlab n'est pas au top Si je sépare la ligne 24 en 2 étapes, cela ne change rien.

Mon but final est d'utiliser Scilab (j'utilise cependant souvent Matlab qd e suis bloqué, avant de faire une transposition). J'avais trouvé une bibliothèque qui répondait à mes besoin (http://help.scilab.org/docs/5.3.1/en...f_lusolve.html), mais qui est optimisée pour les matrices creuses. Bien qu'elle donne de meilleurs résultats que l'inversion "à la bourrin", j'espérais quelque chose de plus propre et mieux optimisé, au moins sous Matlab, et idéalement sous Scilab.

Merci encore,
RémiZ