GENERAZIONE DI UNA MATRICE DI DATO RANGO E TROVARE LE PSEUDO-INVERSE

clear
clc
m = 4, n = 5, r = 3
disp('----------- Costruzione di una matrice mxn di rango r=1 ------------------------------')
for i = 1 : m; a(i) = sin(i*1.35*pi); end
for j = 1 : n; b(j) = cos(j*1.42*pi); end
disp('Sono definiti il vettore colonna a e il vettore riga b')
a = a',b
disp(' si ottiene A = a * b')
A = a * b
disp(strcat('Verifica di Rank(A) = ',num2str(rank(A))))
rank(A)
disp('----------- Costruzione di una matrice mxn di rango r: --------------------------------')
clear a, b;
for k = 1 : r; for i = 1 : m; a(i,k) = sin(i*k*k*1.35*pi); end; end;
for k = 1 : r; for j = 1 : n; b(k,j) = cos(j*k*k*1.42*pi); end; end;
disp('Si considerino i vettori colonna della matrice a:'),a
disp('e i vettori riga della matrice b:'),b

A = zeros(m , n);
for k = 1 : r; disp(strcat('A',num2str(k),' :')), AA = a(1:m , k)*b(k , 1:n), A = A + AA; end;
disp('Matrice A :')
A
disp(strcat('Verifica di Rank(A) = ',num2str(rank(A))))
rank(A)
disp('----------- Decomposizione in valori singolari A = W Lambda Vt -------------------------')
[P1 , LL , Q1] = svd(A);
W = P1(1:m , 1:r)
Lambda = LL(1:r , 1:r)
V = Q1(1:n , 1:r)
disp('Verifica della rappresentazione in valori singolari di A : A - W Lambda Vt = zero')
A - W * Lambda * V'

disp('----------- Decomposizione in valori singolari A = P LL Qt -----------------------------')
disp(' determinazione di null(Wt) e null(Vt)')
nsWt = null(W')
nsVt = null(V')
P = [ W nsWt] , Q = [ V nsVt]
disp('Verifica della rappresentazione in valori singolari di A : A - P LL Qt = zero')
A - P * LL * Q'

disp('----------- Inverse Generalizzate ----------------------------------')
mK = r; nK = m-r; mL = n-r; nL = r; mM = n-r; nM = m-r;
for i=1:mK; for j=1:nK; K(i,j) = sin((i+1)*pi/((j+1)*2.3)); end; end;
for i=1:mL; for j=1:nL; L(i,j) = sin((i+j)*pi/((2*j+1)*2.7)); end; end;
for i=1:mM; for j=1:nM; M(i,j) = sin((i+1)*pi/((i+j)*1.7)); end; end;
Pt = P';

disp('--------------------------------- Inversa Generalizzata A1 ---------')
N1 = Lambda ^(-1);
Lambda1 = [[N1, K],
[L , M]];
A1 = Q * Lambda1 * Pt
disp(' Verifica proprieta 1: A - A A1 A OK')
A - A * A1 * A
disp(' Verifica proprieta 2: A1 - A1 A A1 NO')
A1 - A1 * A * A1
disp(' Verifica proprieta 3: (A*A1)'' - (A1*A) NO')
A1 - A1 * A * A1
disp(' Verifica proprieta 4: (A1*A)''-(A1*A) NO')
(A1*A)'-(A1*A)

disp('--------------------------------- Inversa Generalizzata A12 ---------')
M2 = L * Lambda * K;
Lambda12 = [[N1, K ],
[L , M2]];
A12 = Q * Lambda12 * Pt
disp(' Verifica proprieta 1: A - A A12 A OK')
A - A * A12 * A
disp(' Verifica proprieta 2: A12 - A12 A A12 OK')
A12 - A12 * A * A12
disp(' Verifica proprieta 3: (A*A12)'' - (A12*A) NO')
A12 - A12 * A * A12
disp(' Verifica proprieta 4: (A12*A)''-(A12*A) NO')
(A12*A)'-(A12*A)

disp('--------------------------------- Inversa Generalizzata A14 ---------')
L4 = zeros(size(L));
Lambda14 = [[N1, K ],
[L4, M ]];
A14 = Q * Lambda14 * Pt
disp(' Verifica proprieta 1: A - A A14 A OK')
A - A * A14 * A
disp(' Verifica proprieta 2: A14 - A14 A A14 NO')
A14 - A14 * A * A14
disp(' Verifica proprieta 3: (A*A124)'' - (A124*A) NO')
A14 - A14 * A * A14
disp(' Verifica proprieta 4: (A14*A)''-(A14*A) OK')
(A14*A)'-(A14*A)

disp('--------------------------------- Inversa Generalizzata A124 ---------')
M2 = zeros(size(M));
Lambda124 = [[N1, K ],
[L4, M2 ]];
A124 = Q * Lambda124 * Pt
disp(' Verifica proprieta 1: A - A A124 A OK')
A - A * A124 * A
disp(' Verifica proprieta 2: A124 - A124 A A124 OK')
A124 - A124 * A * A124
disp(' Verifica proprieta 3: (A*A124)'' - (A124*A) NO')
A124 - A124 * A * A124
disp(' Verifica proprieta 4: (A124*A)''-(A124*A) OK')
(A124*A)'-(A124*A)
disp('--------------------------------- Inversa Generalizzata A1234 ---------')
K4 = zeros(size(K));
Lambda1234 = [[N1, K4 ],
[L4, M2 ]];
A1234 = Q * Lambda1234 * Pt
disp(' Verifica proprieta 1: A - A A1234 A OK')
A - A * A1234 * A
disp(' Verifica proprieta 2: A1234 - A1234 A A1234 OK')
A1234 - A1234 * A * A1234
disp(' Verifica proprieta 3: (A*A1234)'' - (A1234*A) OK')
A1234 - A1234 * A * A1234
disp(' Verifica proprieta 4: (A1234*A)''-(A1234*A) OK')
(A1234*A)'-(A1234*A)
disp('--------------------------------- Calcolo MP-inversa con matlab ---------')
disp('--------------------------------- B=pinv(A) ---------')
B=pinv(A)
disp('--------------------------------- Verifica del calcolo della MP-inversa ---------')
disp('--------------------------------- A1234-B ---------')
A1234-B

La ringrazio per l'intervento sul forum.
Però non capisco bene l'obiettivo del programma che ha realizzato, o meglio in cosa si differenzia da quello che ho gia pubblicato sul sito oltre alle ultime righe la determinazione della MP-inversa con l'istruzione "pinv" di MATLAB.
Potrebbe completare con dei commenti il suo intervento sul forum specificando cosa voleva fare e cosa ha ottenuto ?

Infatti come ho detto a lezione, ho solo aggiunto la verifica delle proprietà della MP-inversa per la A1234 (quindi la matrice che verifica tutte e quattro le proprietà), che mancava, e ho verificato che con il comando di matlab "pinv(A)" si ottiene proprio la suddetta matrice.

ah ok va bene cosi allora.