Das M-File 'showlr.m' zeigt analog zur Gauss-Elimination die L-R Faktorisierung Schritt für Schritt.
function [L,R,P] = showlr(A)
%SHOWLR Schrittweise Anzeige der Aktionen in der L-R-Faktorisierung
% showlr(A) fuehrt die L-R-Faktorisierung fuer die Matrix A durch
% showlr benuetzt ein default-Gleichungssystem
% Copyright 2002 HSZ-T , Dr. Stefan Adam
if nargin < 1
% Default-System
A = [ 4 4 8 ; 2 -3 9 ; 1 2 2 ] ;
end
format rat; more off; clc
home
disp(' showlr: Ablauf-Demonstration der L-R-Faktorisierung ')
disp(' Start-Matrix: A '); A
disp('<return> zum Weiterfahren ..'), pause
[m1, n1] = size(A); n = max(m1,n1);
P = eye(n); L = eye(n);
%
% alle Spalten ausser der letzten, (beginnend mit 1)
for kol = 1:(n-1)
% ['L' int2str(kol)] = eye(n);
Ltmp = eye(n);
% Null-Test des Pivot-Kandidaten, evtl. vertauschen
if A(kol,kol) == 0
[amx,kx] = max(abs(A(kol:n,kol)));
if amx == 0; disp('Matrix singulaer!'); return; end
% Absoluter Vertauschungs-Index, statt relativ zu kol
kx=kx+kol-1;
home
disp([' Zeilenvertauschung noetig: ', int2str(kol) , ' <==> ', int2str(kx) ])
% vertauschen Rest-Zeilen
hz=A(kol,kol:n); A(kol,kol:n) = A(kx,kol:n); A(kx,kol:n) = hz;
% vertauschen rechte Seiten
hb = b(kol); b(kol) = b(kx); b(kx) = hb;
% partielle und dann totale Permutationsmatrix
PP = eye(n); PP(kol,kol) = 0; PP(kx,kx) = 0;
PP(kx,kol) = 1; PP(kol,kx) = 1; P = PP*P;
P
end
Aol = A;
% Pivot-Absicherung OK, Kombinationen durchfuehren
% alle Zeilen unterhalb der Diagonalen
for lin = (kol+1):n
% ~~~Division nur einmal ausf\"uhren, da immer dieselbe
comb = A(lin,kol)/A(kol,kol);
% ~~~ entsprechende Zeilen kombinieren
% ~~~ Elementaufzaehlung mit impliziter Schleife
A(lin,kol:n) = A(lin,kol:n) - A(kol,kol:n)*comb;
Ltmp(lin,kol) = -comb; R=A; clc
home
disp(' showlr: Ablauf-Demonstration der L-R-Faktorisierung ')
Aol
disp([' Schritt ' int2str(kol) ' , Sub-Schritt ' int2str(lin-kol) ...
': Element A(' int2str(lin) ',' int2str(kol) ') wird 0 . ' ])
disp([' durch A(',int2str(lin),',:) = A(',int2str(lin),':) + (', ...
num2str(-comb),')*A(',int2str(kol),',:)' ])
%
if (kol == n-1 ) & ( lin == n); R
else ; A
end
Ltmp
%['L' int2str(kol)] = Ltmp
Aol = A;
disp('<return> zum Weiterfahren ..'), pause
end
% L akkumulieren mit Rechts-Multiplikation von Ltmp
L = L*(Ltmp^(-1));
end
% Schluss-Test auf Ann == 0
if A(n,n) == 0; disp('Matrix singulaer!'); return; end
% L-Matrizen zusammenstellen
clc; home
disp(' showlr: Ablauf-Demonstration der L-R-Faktorisierung ')
P, R ,L
format short
function Ainv = showgaussjor(A)
%SHOWGAUSSJOR Schrittweise Anzeige der Aktionen im Gau{\ss}--Jordan-Algorithmus
% showgaussjor(A) Invertiert A
% showgaussjor invertiert eine default-Matrix
% Copyright 2003 HSZ-T , Dr. Stefan Adam
if nargin < 1
% Default-System
A = [ 4 4 8 ; 2 -3 9 ; 1 2 2 ] ;
end
%format rat % kann eventuell reaktiviert werden fuer einfachere Anzeigen
more off ; clc
[m1,n1] = size(A); n = max(m1,n1); pvec = 1:n; AI = [A eye(n)];
home
disp(' showgaussjor: Ablauf-Demonstration des Gauss--Jordan-Algorithmus ')
disp(' Start-Matrix: [A I] '); AI
disp('<return> zum Weiterfahren ..'), pause
Rang = n;
%
% 1. Gau{\ss}-Eliminations-Teil
% alle Spalten ausser der letzten, (beginnend mit 1)
%
for kol = 1:(n-1)
% Null-Test des Pivot-Kandidaten, evtl. vertauschen
if AI(kol,kol) == 0
[amx,kx] = max(abs(AI(kol:n,kol)));
if amx == 0; disp('Matrix singulaer!'); Rang = Rang -1;
break; end
% Absoluter Vertauschungs-Index, statt relativ zu kol
kx=kx+kol-1; home
disp([' Zeilenvertauschung noetig: ', int2str(kol) , ' <==> ', int2str(kx) ])
% vertauschen Rest-Zeilen
hp = pvec(kol); pvec(kol) = pvec(kx); pvec(kx) = hp;
hz=AI(kol,kol:n*2); AI(kol,kol:n*2)=AI(kx,kol:n*2); AI(kx,kol:n*2)=hz;
AI
end
% Pivot-Absicherung OK, Kombinationen durchfuehren
% alle Zeilen unterhalb der Diagonalen
for lin = (kol+1):n
AIol = AI;
% ~~~Division nur einmal ausfuehren, da immer dieselbe
comb = AI(lin,kol)/AI(kol,kol);
% ~~~ entsprechende Zeilen kombinieren
% ~~~ Elementaufzaehlung mit impliziter Schleife
AI(lin,kol:n*2) = AI(lin,kol:n*2) - AI(kol,kol:n*2)*comb;
RH=AI; clc; home
disp(' showgauss: Ablauf-Demonstration des Gauss-Algorithmus ')
AIol
disp([' Schritt ' int2str(kol) ' , Sub-Schritt ' int2str(lin-kol) ...
': Element A(' int2str(lin) ',' int2str(kol) ') wird 0 . ' ])
disp([' durch A(',int2str(lin),',:) = A(',int2str(lin),':) + (', ...
num2str(-comb),')*A(',int2str(kol),',:)' ])
if (kol == n-1 ) & ( lin == n); RH
else; AI
end; AIol = AI;
disp('<return> zum Weiterfahren ..'), pause
end
end
% Schluss-Test auf Ann == 0
if AI(n,n) == 0; disp('Matrix singulaer!'); Rang = Rang -1; end
Rang
% Jordan Eliminations-Teil
clc ; RH = AI
home; disp(' Jordan-Eliminations-Teil ')
% rueckwaerts alle Spalten ausser der ersten, (beginnend mit n)
%
for kol = n:-1:2
% keine Pivot-Vertauschungen mehr noetig
% Null-Test des Pivot-Kandidaten trotzdem sinnvoll
if RH(kol,kol) == 0; disp('Matrix singulaer!') ; return
else; RHol = RH;
% alle Zeilen oberhalb der Diagonalen
for lin = (kol-1):-1:1
% ~~~Division nur einmal ausf\"uhren, da immer dieselbe
comb = RH(lin,kol)/RH(kol,kol);
% ~~~ entsprechende Zeilen kombinieren
% ~~~ Elementaufzaehlung mit impliziter Schleife
RH(lin,lin:n*2) = RH(lin,lin:n*2) - RH(kol,lin:n*2)*comb;
DG=RH; clc; home
disp(' showgaussjor: Ablauf-Demonstration Jordan-Elimination ')
RHol
disp([' Jordan-Schritt ' int2str(kol) ' , Sub-Schritt ' int2str(kol-lin) ...
': Element A(' int2str(lin) ',' int2str(kol) ') wird 0 . ' ])
disp([' durch A(',int2str(lin),',:) = A(',int2str(lin),':) + (', ...
num2str(-comb),')*A(',int2str(kol),',:)' ])
if (kol == 2 ) & ( lin == 1); DG
else; RH
end; RHol = RH;
disp('<return> zum Weiterfahren ..'), pause
end % Verarbeitung dieser Spalte fertig
end % Schleife 1:n-1 ueber Spalten
end
% Skalierungs-Teil
clc
home
DG
IB = DG;
disp(' Skalierungs--Teil ')
for k = 1:n
s = 1/IB(k,k); IB(k,k) = 1; IB(k,n+1:2*n) = s*IB(k,n+1:2*n);
end
IB
Ainv = IB(:,n+1:2*n)
pvec
disp('<return> zum Weiterfahren ..'), pause