57: end

1: function [ B]=UBINV(B);
2: %——————————————————– 1: function [X]=UTRIINVa(B,C)
3: % Algoritmul calculeaza inversa unei matrice 2: %—————————————————————
patratica ————
4: % B(nxn) superior bidiagonala. Inversa suprascrie 3: % Algoritmul calculeaza inversa unei matrice
5: % triunghiul superior al matricei B. superior tridiagonale
6: % Apelul: B=UBINV(B) 4: % patratice A(nxn).Ca date de intrare avem doar
7: % matricele superior
8: % 5: % bidiagonale B(nxn) si C(nxn). Matricea A este
11: [ n,m]=size(B); rezultatul inmultirii
30: 6: % celor doua matrice. Pasii de calculare ai inversei
31: for j=n:-1:1 sunt urmatorii:
32: B(j,j)=1/B(j,j); 7: % se calculeaza inversa matricei B care se
33: for i=j-1:-1:1 suprascrie in B si inversa
34: B(i,j)=-B(i,i+1)*Y(i+1,j)/ B(i,i); 8: % matricei C care se suprascrie in C. Inversa
35: end matricei A este rezultatul
36: end 9: % inmultirii celor doua matrice.
10: % Apelul: X=UTRIINVa(B,C)
1: function [ x]=UBSM1(B,C,d) 11: %
2: %————————————————————— 14:
————– 15: [ n,m]=size(B);
3: % Programul calculeaza solutia sistemului liniar 16:
Ax=d, unde A=B*C. Ca date 42: Y=UBINV(B); %calculeaza inversa matricei B
4: % de intrare avem vectorul d si matricele 43: B=Y;
nesingulare superior bidiagonale 44: Z=UBINV(C); %calculeaza inversa matricei C
5: % B(nxn) respectiv C(nxn) care inmultite dau 45: C=Z;
matricea A(nxn). Pasi de 46: for i=1:n %efectueaza inmultirea noilor matrice B
6: % rezolvare: intai se calculeaza matricea A si C
superior tridiagonala cu formula 47: for j=1:n
7: % A=B*C apoi se rezolva sistemul liniar Ax=d. 48: X(i,j)=0;
8: % Nota: folosim numele de UBSM pentru upper 49: end
bidiagonal matrix solver 50: for j=i:n
9: % Apelul: x=UBSM1(B,C,d) 51: for k=i:j
10: % 52: X(i,j)=X(i,j)+C(i,k)*B(k,j);
14: [ n,m]=size(B); 53: end
40: 54: end
41: for i=1:n 55: end
42: for j=1:m
43: A(i,j)=0;
44: end 1: function [ x]=UTRIS(U,b)
45: A(i,i)=B(i,i)*C(i,i); 2: %—————————————————————
46: if i<n ———–
47: A(i,i+1)=B(i,i)*C(i,i+1)+B(i,i+1)*C(i+1,i+1); 3: % Fiind data o matrice superior triunghiulara
48: end patratica A (nxn) si un
49: if i<n-1 4: % vector b, algoritmul calculeaza sistemul liniar
50: A(i,i+2)=B(i,i+1)*C(i+1,i+2); Ax=b.
51: end 5: % UTRIS=upper triunghiular solver.
52: end 6: % Apelul: x=UTRIS(U,b)
53: x(n)=d(n)/A(n,m); 7: %
54: x(n-1)=(d(n-1)-A(n-1,m)*x(n)) / A(n-1,m-1); 10:
55: for i=n-2:-1:1 11: [m,n] = size(U);
56: x(i)=(d(i) - A(i,i+1)*x(i+1)- A(i,i+2)*x(i+2))/ A(i,i); 12:
13: if m~=n 4: % algoritmul calculeaza o matrice inferior
14: % in caz ca nu este o matrice patratica bidiagonala L si o matrice
15: x = [ ];%x devine o matrice nula 5: % superior unitate triunghiulara U astfel incat
16: return; H=L*U. Matricea L este
17: end 6: % suprascrisa partii inferior triunghiulare a
18: matricei A(inclusiv diagonala)
19: if m~=length(b) 7: % iar matricea U este suprascrisa partii superior
20: error(’Nu exista solutie pentru’); triunghiulare a
21: end 8: % matricei A(fara diagonala).
22: 9: % Apelul: H=CROUT HESS(H)
23: for i=n:-1:1 10: %
24: s = b(i); 13:
25: if i<n 14: [ n,m]=size(H);
26: for k=i+1:n 29:
27: s = s - U(i,k)*x(k); 30: for i=1:n
28: end 31: U(i,i)=1;
29: end 32: end
30: x(i) = s/U(i,i); 33:
33: end 34: for j=2:n-1
34: end 35: U(1,j)=H(1,j)/H(1,1);
36: H(1,j)=U(1,j);
1: function [H,b,miu]=G HESS(H,b) 37: end
2: %————————————————————— 38:
———— 39: for k=2:n
3: % Fiind data o matrice superior Hessenberg 40: L(k,k)=H(k,k)-H(k,k-1)*H(k-1,k);
nesingulara, patratica (nxnx) 41: H(k,k)=L(k,k);
4: % cu toate submaticele lider principale 42: if k∼=n
nesingulare, se cere rezolvarea 43: for j=k+1:n
5: % sistemului liniar Hx=b. Algoritmul reprezinta o 44: U(k,j)=(H(k,j)-H(k,k-1)*H(k-1,j))/H(k,k);
adaptare a algoritmului 47: end
6: % de eliminare gaussiana fara pivotare. Algoritmul 48: H(k,j)=U(k,j)
G HESS calculeaza 49: end
7: % factorizarea LU Doolittle a matricei H. 50: end
8: % Apelul: H,b,miu=G HESS(H,b) 51: end
9: %
13: [ n,m]=size(H);
28: 1: function [H,p]=GPP HESS(H)
29: for k=1:n-1 %Multiplicatorii gaussieni si matricea 2: %—————————————————————
30: miu(k+1,k)=H(k+1,k)/H(k,k); %superior —————
triunghiulara rezultata vor suprascrie matricea H 3: % Data o matrice superior Hassenberg H
33: end patratica(de ordin n), algoritmul
34: H(k+1,k)=miu(k+1,k); 4: % efectueaza eliminarea gaussiana cu pivotare
35: for j=k+1:n partiala. Multiplicatorii
36: H(k+1,j)=H(k+1,j)-miu(k+1,k)*H(k,j); 5: % gaussieni si matricea superior triunghiulara
37: end rezultata vor suprascrie
38: b(k+1)=b(k+1)-H(k+1,k)*b(k); 6: % matricea H.
39: end 7: % Apelul: H,p=GPP HESS(H)
8: %
1: function [H]=CROUT HESS(H) 12: [ n,m]=size(H);
2: %————————————————————— 27:
————- 28: for k=1:n-1
3: % Data o matrice superior Hessenberg H 29: p(k)=k;
nesingulara patratica (nxn) 30: max = abs( H(k,k) );
31: if abs( H(k+1,k) ) >max 5: % strict inferior al lui A este suprascris de
32: max = abs( H(k+1,k) ); multiplicatorii gaussieni
33: end 6: % miu. In vectorul p se memoreaza intregii i(k),
34: p(k)=k+1; care definesc permutarile
35: for j=k:n 7: % de linii.
36: temp = H(k,j); 8: % Apelul: A,miu,p=GPP(A)
37: H(k,j) = H(k+1,j); 9: %
38: H(k+1,j) = temp;
39: end 12:
40: miu(k+1,k) = H(k+1,k)/H(k,k); 13:
43: end 14: [ n,m] = size(A);
44: H(k+1,k)=miu(k+1,k); 20:
45: for j = k+1:n 21: for k=1:n-1
46: H(k+1,j)=H(k+1,j)-miu(k+1,k)*H(k,j); 22: ik = k;
47: end 23: max = abs( A(k,k) );
48: end 24:
49: 25: for i=k:n
1: function [ x]=LSS GPP HESS(H,b) 26: if abs( A(i,k) ) >max
2: %————————————————————— 27: ik = i;
—————- 28: max = abs( A(i,k) );
3: % Fiind data o matrice superior Hassenberg 29: end
nesingulara H patratica (de 30: end
4: % ordin n) si un vector b, algoritmul calculeaza 31:
solutia x a sistemului 32: p(k)=ik;
5: % Hx=b folosind eliminarea gaussiana cu pivotare 33:
partiala. 34: for j=k:n
6: % Apelul: x=LSS GPP HESS(H,b) 35: temp = A(k,j);
10: 36: A(k,j) = A(ik,j);
11: [ n,m]=size(H); 37: A(ik,j) = temp;
12: 38: end
27: %conditionam ca numarul liniilor vectorului b sa 39:
fie egal cu numarul coloanelor 40: for i=k+1:n
28: %matricei H 41: miu(i,k) = A(i,k)/A(k,k);
32: 42: if A(k,k)==0
33: [H,p]=GPP HESS(H); 43: error(’Matricea nu este nesingulara’)
34: for k=1:n-1 44: end
35: if p(k)==k+1 45: A(i,k)=miu(i,k);
36: temp=b(k); 46:
37: b(k)=b(k+1); 47: end
38: b(k+1)=temp; 48:
39: end 49: for i=k+1:n
40: b(k+1)=b(k+1)-H(k+1,k)*b(k); 50: for j = k+1:n
41: end 51: A(i,j)=A(i,j)-miu(i,k)*A(k,j);
42: 52: end
43: x=UTRIS(triu(H),b) 53: end
44: 54: end
1: function [A,miu,p]=GPP(A) 55:
2: %————————————————————— 1: function [A]=G prim(A)
————— 2: %—————————————————————
3: % Data o matrice patratica A(nxn), algoritmul ——-
suprascrie triunghiul 3: % Data fiind matricea patratica A(nxn) algoritmul
4: % superior al lui A cu matricea superior calculeaza matricea
triunchiulara U. Triunghiul
4: % L pe care o suprascrie partii inferioare 50: L(k+1,k)=T(k+1,k)/L(k,k);
triunghiulare a lui A si 53: end
5: % multiplicatorii miu pe care ii suprascriu partii 54: T(k+1,k)=L(k+1,k);
superior triunghiulare 55: end
6: % a lui A. Practic alogritmul ofera o factorizare UL 56: end
(furnizeaza o 1: function [A]=UUT(A)
7: % matrice unitate superior triunghiulara U si una 2: %—————————————————————
inferior triunghiulara —————–
8: % L astefl incat A=U*L) 3: % Fiind data o matrice simetrica si pozitiv definita,
9: % Apelul: A=G prim(A) propuneti un algoritm
10: % 4: % pentru factorizarea A=U*U transpus. Aici U este
13: superior triunghiulara si
14: [ n,m]=size(A); 5: % are elemente pozitive pe diagonala. Practic,
20: algoritmul stabileste daca
21: for k=n:-1:2 6: % matricea A este pozitiv definita, in caz afirmativ,
22: for i=1:k-1 suprascrie partea
23: miu(i,k)=A(i,k)/A(k,k); 7: % superioara cu matricea U.
26: end 8: % Apelul: A=UUT(A)
27: A(i,k)=miu(i,k); 12:
28: end 13: [ n,m]=size(A);
29: for j=1:k-1 14:
30: for i=1:k-1 31: U(n,n)=sqrt(A(n,n));
31: A(i,j)=A(i,j)-miu(i,k)*A(k,j); 32: A(n,n)=U(n,n);
32: end 33: for i=1:n-1
33: end 34: U(i,n)=A(i,n)/U(n,n);
34: end 35: A(i,n)=U(i,n);
36: end
1: function [T]=CHOL TRID(T) 37: for k=n-1:-1:1
2: %————————————————————— 38: s=0;
———– 39: for j=k+1:n
3: % Fiind data o matrice T patratica (de ordin n), 40: s=s+U(k,j)*U(k,j);
tridiagonala, simetrica 41: end
4: % pozitiv definita, nesingulara care satisface 42: alpha=A(k,k)-s;
relatia: T=L*L transpus 45: end
5: % algoritmul suprascrie partea inferior 46: U(k,k)=sqrt(alpha);
triunghiulara a matricei T cu 47: A(k,k)=U(k,k);
6: % matricea L. Obs: matricea L rezulta prin 48: if k∼1
identificare a fi inferior 49: for i=1:k-1
7: % bidiagonala. 50: suma=0;
8: % Apelul: T=CHOL TRID(T) 51: for j=k+1:n
9: % 52: suma=suma+U(i,j)*U(k,j);
12: 53: end
13: [ n,m]=size(T); 54: U(i,k)=(A(i,k)-suma)/U(k,k);
14: 57: end
41: 58: A(i,k)=U(i,k);
42: L(1,1)=sqrt(T(1,1)); 59: end
43: T(1,1)=L(1,1); 60: end
44: L(2,1)=T(2,1)/L(1,1); 61: end
45: T(2,1)=L(2,1);
46: for k=2:n
47: L(k,k)=sqrt(T(k,k)-L(k,k-1)*L(k,k-1));
48: T(k,k)=L(k,k);
49: if k∼=n