1

Curs 2
Sisteme de ecuaii liniare
Un sistem de ecuaii liniare are forma general:

= + + +
= + + +
= + + +
n n nn n n
n n
n n
b x a x a x a
b x a x a x a
b x a x a x a

2 2 1 1
2 2 2 22 1 21
1 1 2 12 1 11

sau matricial:
A.x=b n care AeR
nxn
, beR
n

Sistemul admite soluia unic xeR
n
dac matricea este inversabil, caz n care soluia se
exprim sub forma:
x=A
-1
.b
Metodele de rezolvare :
- metode exacte - care furnizeaz soluia exact a sistemului dac se neglijeaz erorile de
rotunjire.
- metode aproximative sau iterative - care construiesc un ir , convergent ctre soluia exact
a sistemului .
- Metodele directe aduc sistemul prin transformri de echivalen, la un sistem particular
(diagonal, triunghiular, etc), care se rezolv cu mijloace elementare.
- Metodele exacte se bazeaz pe factorizare gaussian sau pe factorizare ortogonal.
- Complexitatea metodelor exacte este O(n
3
), motiv care le restrnge aplicabilitatea la
rezolvarea sistemelor de ordin nu prea mare (n<1000)
- In cazul metodelor aproximative, procesul iterativ de generare a irului x
(k)
este oprit la
un rang p, n momentul n care x
(p)
reprezint o aproximaie satisfctoare a soluiei .
- Complexitatea metodelor iterative este O(n
2
) ntr-un pas, ele fiind recomandate pentru
rezolvarea sistemelor mari (n>50), dac se asigur o convergen rapid..
Metode gaussiene directe
Rezolvarea sistemelor triunghiulare
Presupunem condiia de nesingularitate pentru un sistem triunghiular a
ii
=0
sistem superior triunghiular cu a
ij
=0 pentru i>j.






sistem inferior triunghiular cu a
ij
=0 pentru i<j.



n n nn
2 n n 2 2 22
1 n n 1 2 12 1 11
b x a
b x a x a
b x a x a x a
=
= + +
= + + +

n n nn 2 2 n 1 1 n
2 2 22 1 21
1 1 11
b x a x a x a
b x a x a
b x a
= + + +
= +
=

2
Sistemul superior triunghiular se rezolv prin substituie napoi folosind relaiile




Sistemul inferior triunghiular se rezolv prin substituie nainte cu relaiile:




function x = SST1(A, b)
% rezolvare sistem superior triunghiular
% Intrari: A=matrice sistem
% b=vector termeni liberi
% Iesiri: x=vector necunoscute
[n, n] = size(A);
x = zeros(n,1);
x(n) = b(n)/A(n, n);
for i = n-1:-1:1
x(i)=(b(i)-A(i,i+1:n)*x(i+1:n))/A(i,i);
end
Metod recursiv
Scriem separat ultima linie din sistemul inferior triunghiular:



Pentru a obine un algoritm recursiv

function x = SITrec(n, A, b)
% rezolvare recursiva sistem inferior triunghiular
if n == 1
x(1,1)=b(1)/A(1,1);
else
x(1:n-1,1)=SITrec(n-1, A(1:n-1,1:n-1), b(1:n-1));
x(n,1) = (b(n,1)-A(n,1:n-1)*x(1:n-1,1))/A(n,n);
end
Rezolvare pe coloane
O versiune orientat pe coloane este:
function x = SITcol(A, b)
% rezolvare orientata pe coloane a
% sistemului inferior triunghiular
[n,n] = size(A);
x = b;
for k = 1 : n
x(k) = x(k)/A(k, k);
x(k+1:n)=x(k+1:n)x(k)*A(k+1:n,k);
end
1 : 1 : n i ,
A
x A b
x
ii
n
1 i j
j ij i
i
=

=

+ =
n : 1 i ,
A
x A b
x
ii
1 i
1 j
j ij i
i
=

=
(

=
(

n
1
n
1
nn
T
1 n
11

x
a
0 A
3
Eliminare gaussian.
Teorem Dac A
[p]
=(a
ij
)
1si,j sn
, A
[p]
eR
nxn
,cu p=1:n sunt nesingulare, atunci exist ,
TeR
nxn
nesingular i inferior triunghiular astfel nct matricea T*A=U este superior
triunghiular.
Formm o transformare elementar
T
p
=I
n
-t
p
*e
p
T
n care I
n
este matricea unitate e
p
este coloana p a acesteia, iar t
p
, un vector coloan, pe
care-l vom numi vector Gauss, cu primele componente nule i celelalte, deocamdat
neprecizate:
t
p
=[0...0 t
p+1,p
...t
np
]
T

Determinm transformarea T
p
astfel nct atunci cnd se aplic asupra unui vector xeR
n
i las
primele p componente nemodificate i i anuleaz restul componentelor:
T
p
x=(I
n
-t
p
e
p
T
)x=x-t
p
(e
p
T
x)=x-t
p
x
p

de unde:
( )

>
s
= =
p i , x t x
p i , x
x t x x T
p ip i
i
p ip i
i
p

Impunnd anularea ultimelor componente obinem:
n : 1 p i ,
x
x
t
p
i
ip
+ = =
Aadar vectorul Gauss este:
T
p
n
p
1 p
p
x
x
x
x
0 0 t
(
(

=
+

function [t,x]=VecG(p,x)
% determina vectorul Gauss asociat unui vector x,
% caruia ii anuleaza componentele x[p+1:n]
x=x(:);
n=length(x);
t=zeros(n,1);
t(p+1:n)=x(p+1:n)./x(p);
x(p+1:n)=0;
Aplicm transformarea T
p
asupra unui vector oarecare yeR
n
:
T
p
.y = (I
n
t
p
.e
p
T
).y = y t
p
.(e
p
T
.y) = y t
p
.y
p

( )

>
s
=
p i , y
x
x
y
p i , y
y T
p
p
i
i
i
i
p

function y=TG(y,p,t)
% aplica transformarea Gauss unui vector oarecare y
y=y(:); %ii facem vectori
t=t(:);
4
n=length(t);
y(p+1:n)=y(p+1:n)-t(p+1:n).*y(p)
(
(
(
(
(
(

=
(
(
(
(
(
(

(
(
(
(
(
(

+ +
nn
pn pp
n 2 p 2 22
n 1 p 1 11
nn p , n
pn p , 1 p
pp
n 2 p 2 22
n 1 p 1 11
p , n
p , 1 p
a 0 0
0
a a
a a a 0
a a a
a a 0 0
a a 0 0
a
a a a 0
a a a
1 t
t
1
0 0 1 0
0 0 0 1

Considerm ca vector x coloana p a matricei A (parial adus la form triunghiular), iar vector y
vor fi pe rnd coloanele j ale matricei A situate n dreapta coloanei p (j>p)
T
p
*A
p
=A
p+1
T
p
.A
p
= T
p
.[a
1
... a
p
... a
n
] = [T
p
.a
1
...T
p
.a
p
... T
p
.a
n
]
Pornind cu matricea A ptrat se aplic pe rnd o transformare Gauss coloanelor 1,2, n-1

Matricea general de transformare T=T
n-1
...T
2
T
1
va determina obinerea unei matrici transformate T*A superior triunghiular

function [A, b] = Gauss(A, b)
% triunghiularizare prin eliminare Gauss
% Intrri :
% A = matrice sistem
% b = vector termeni liberi
% Ieiri :
% A = matrice sistem superior triunghiular
% b = termeni liberi sistem triunghiular
[n, n] = size(A);
for p = 1:n 1
[t,A(:,p)]=VecG(p,A(:,p));
for j=p+1:n
A(:,j)=TG(A(:,j),p,t);
end
b=TG(b,p,t);
end
Algoritmul poate fi simplificat innd cont c transformarea Gauss aplicat vectorului A(:,p)
nu i modific primele p componente, deci ar putea fi aplicat vectorului A(p+1:n, p),
eliminnd parametrul p din funciile VecG() i TG() n care p devine 1.
function [t,x]=VecG(x)
% determina vectorul Gauss asociat
% unui vector x,caruia ii anuleaza
% componentele x[p+1:n]
x=x(:);
n=length(x);
t=zeros(n,1);
t(2:n)=x(2:n)/x(1);
x(2:n)=0;

function y=TG(y,t)
% aplica transformarea Gauss
5
% unui vector oarecare y
y=y(:); %ne asiguram ca sunt
t=t(:); %vectori
n=length(t);
y(2:n)=y(2:n)-t(2:n)*y(p)

function [A, b] = Gauss(A, b)
% triunghiularizare sistem
% prin eliminare gaussiana
% Intrari : A = matrice sistem
% b = vector termeni liberi
% Iesiri : A = matrice sistem triunghiular
% b = termeni liberi sistem triunghiular
[n, n] = size(A);
for p = 1 : n-1
for i=p+1 : n
t = A(i, p) / A(p, p);
A(i,p:n) = A(i, p:n) - t* A(p, p:n);
b(i) = b(i) - t * b(p);
end
end
Eliminare gaussian cu pivotare parial
Procesul de triunghiularizare eueaz dac elementul diagonal actualizat este nul, i.e. dac
submatricea a matricei iniiale este nul. Chiar pentru valori nenule, dar mici ale acestuia
stabilitatea numeric a metodei este afectat.
Strategia de pivotare parial alege dintre liniile i=p:n acea linie q pentru care elementul
conductor A
qp
este maxim n valoare absolut.
Eliminare gaussian cu pivotare total
Se alege ca element principal pivot, primul element maxim n valoare absolut A
lm
, din
submatricea delimitat de ultimele n-p+1 linii i coloane ale matricei A
p
, pentru ca acesta s
ocupe poziia (p,p) trebuiesc interschimbate liniile l i p i coloanele m i p.
Aceast transformare total stabilizat se exprim prin A
p+1
=T
p
P
pl
A
p
P
pm
nmulirea la stnga cu P
pl
permut n A
p
liniile p i l>p
nmulirea la dreapta cu P
pm
permut A
p
n coloanele m i m >p
|
|
|
.
|

\
|
=
|
|
|
.
|

\
|

|
|
|
.
|

\
|

+ +

1 p
*
1 p
b
p pl p
x
p pm
A
pm p pl p
b P T x P P A P T
Se observ c n cursul transformrii, x este premultiplicat cu P
pm
, ceeace conduce la
permutarea componentelor k i m. Aceasta impune inerea evidenei schimbrilor de
coloane, printr-un vector de indexare a lui x.
Factorizare LU
Dac A
[p]
=(a
ij
)
1si,j sp
cu p=1:n sunt nesingulare atunci exist o matrice LeR
nxn
,
nesingular triunghiular inferioar i o matrice UeR
nxn
, nesingular triunghiular
superioar astfel ca A=LU.
6
Sistemul Ax=b poate fi rescris LUx=b sau
Ly=b
Ux=y
Rezolvarea sistemului se reduce la rezolvarea a dou sisteme triunghiulare.
In MATLAB se folosete funcia [L, U] = lu(A)
Factorizare direct Crout
( )

=
=
j , i min
1 m
mj im ij
U L A

=
= = + =
1 p
1 m
1 p
1 m
mp im ip ip pp ip mp im ip
n : p i , U L A L U L U L A

= + =
1 p
1 m pp
1 p
1 m
mj pm pj
pj pj pp mj pm pj
L
U L A
U U L U L A
function A = crout(A)
% factorizare directa Crout
% Intrri: A = matricea de factorizat
% Ieiri: A = matricele factori
[m, n] = size(A);
for p = 1 : n
for i = p : n
s = A(i,1:p-1)*A(1:p-1,p);
A(i,p) = A(i,p) s;
end;
for j = p+1 : n
s = A(p,1:p-1)*A(1:p-1,j);
A(p,j) = (A(p,j) - s) / A(p,p);
end
end
Factorizare Cholesky
Dac matricea sistemului este:
simetric (A
ij
= A
ji
sau A = A
T
)
pozitiv-definit (x
T
.

A.x>0, x e R
n
, x = 0)
factorizarea are forma particular A=L.L
T
=R
T
.R

=
=
1 i
1 k
2
ik ii ii
L A L , i = 1 : n
jj
1 j
1 k
jk ik ij
ij
L
L L A
L

= j = 1 : i-1


7
Rezolvarea sistemelor tridiagonale

= +
= + +
= + +
= +

+
n n n 1 n n
i 1 i i i i 1 i i
2 3 2 2 2 1 2
1 2 1 1 1
d x b x a
d x c x b x a
d x c x b x a
d x c x b

Prin eliminare gaussian sistemul devine bidiagonal :

=
= +
= +
= +
+
n n n
i 1 i i i i
2 3 2 2 2
1 2 1 1 1
d x b
d x c x b
d x c x b
d x c x b

Eliminare subdiagonal
1 p
1 p
p
p p
c
b
a
b b

=
n : 2 p ,
b
a
d d
1 p
p
p p
= =

Rezolvare sistem 2-diagonal
n
n
n
b
d
x =

1 : 1 : 1 n i ,
b
x c d
x
i
1 i i i
i
=

=
+

Rezolvarea sistemelor tridiagonale
function d = tridi(a, b, c, d)
% Intrri: a = subdiagonal
% b = diagonal principal
% c = supradiagonal
% d = termeni liberi
% Ieiri: d = necunoscute
%eliminare element subdiagonal
a = a(:);
[m, n] = size(A);
for i = 2 : n
t = a(i) / b(i-1);
b(i) = b(i) - t * c(i-1);
d(i) = d(i) - t * d(i-1);
end
% rezolvarea sistemului bidiagonal
d(n) = d(n) / b(n);
8
for i = n-1 : 1 : 1
d(i) = (d(i) - c(i) * d(i+1)) / b(i);
end
Inversarea matricelor
Inversarea matricelor triunghiulare
A.B=I
n
B=A
-1
matrice superior triunghiular
n : 1 j ,
a
1
b
jj
jj
= =
1 : 1 : 1 j i , b a
a
1
b
j
1 i k
kj ik
ii
ij
= =

+ =

matrice inferior triunghiular
n : 1 i ,
a
1
b
ii
ii
= =
1 i : 1 j , b a
a
1
b
1 i
j k
kj ik
ii
ij
= =

=

Inversarea matricelor triunghiulare
function B = invTrSup(A)
% inversare matrice superior-triunghiulara
% Intrri: A=matrice superior triunghiular
% Ieiri: B = inversa matricii A
[n, n] = size(A);
for j = n : -1 : 1
B(j, j) = 1 / A(j, j);
for i = j - 1 : -1 : 1
B(i,j)=-A(i,i+1:j)*B(i+1:j,j)/A(i,i);
end
end
B = triu(B);
Metoda Gauss-Jordan
B=[A | I
n
]
- normalizare: n 2 : p j , n : 1 p ,
A
A
A
pp
pj
pj
= = =
- reducere: A
ij
= A
ij
-A
ip
A
pj
, p = 1 : n, i = 1 : n, j = p : 2n

function X = invGauss(A)
% inversare matrice prin rezolvare
% simultana a n sisteme
% Intrri:A = matricea de inversat
% Ieiri: X = matricea invers
[m, n] = size(A);
X=eye(n);
9
% triunghiularizare sisteme
for p = 1 : n-1
for i = p+1 : n
t = A(i,p) / A(p,p);
A(i,p) = 0;
A(i,p+1:n) = A(i,p+1:n)-t * A(p,p+1:n)
end
X(i,1:n) = X(i,1:n) - t * X(p,1:n);
end
% rezolvare sisteme triunghiulare
for i = n : -1 : 1
for k = 1 : n
suma = A(i,i+1:n)*X(i+1:n,k);
X(i,k) = (X(i,k) - suma) / A(i,i)
end
end