function Ainv = showgaussjor(A)
%SHOWGAUSSJOR Schrittweise Anzeige der Aktionen im Gauss-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. Gauss-Eliminations-Teil 
% alle Spalten ausser der letzten, (beginnend mit 1)
%
for kol = 1:(n-1)
% Null-Test des Pivot-Kandidaten, ev. 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 ausf{\"u}hren, da immer dieselbe
    comb =  AI(lin,kol)/AI(kol,kol);
% ~~~ entsprechende Zeilen kombinieren
% ~~~ Element-Aufzaehlung 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{\"u}hren, da immer dieselbe
      comb = RH(lin,kol)/RH(kol,kol);
% ~~~ entsprechende Zeilen kombinieren
% ~~~ Element-Aufzaehlung 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
