II) Programmumsetzungen

Die drei obigen Algorithmen per Hand auszuführen wäre sehr zeitaufwendig und mühselig. Ständig diesselben Rechenoperationen zu betreiben, wären für einen Menschen zu ermüdend. Ein einziger Rechenfehler würde die ganze Arbeit wertlos machen, da dieser Rechenfehler das Ergebnis völlig verfälschen würde.
Mehr an Bedeutung gewinnen die Algorithmen, wenn man sie von Computern ausführen läßt. So lassen sich Rechenfehler ausschließen, man muß lediglich noch mit Rundungsfehlern zurechtkommen. Außerdem ist die Ausführungszeit fast vernachlässigbar, in Bruchteilen von Sekunden wird das Ergebnis vom Computer berechnet.
Weil der Computer einen Algorithmus nicht einfach bearbeiten kann, muß man diesen erst in eine für den Computer verständliche Form umsetzten. Die Umsetzung ist dann ein Computerprogramm.
Die Entwicklungen für Computerprogramme der drei beschriebenen Algorithmen soll nachfolgend vollzogen werden. Die Programme werden in PASCAL geschrieben und sollten systemunabhängig sein.
Im folgenden Verlauf wird zunächst das Grundprinzip und dann erst das fertige Programm, das, wie das zugehörige Ablaufprotokoll, im Anhang zu finden ist. Es empfiehlt bei der Programmbeschreibung, den Programmquelltext vor sich liegen zu haben, um die einzelnen Schritte besser verfolgen zu können.
Bei der Programmierung wurde darauf geachtet, daß sich die einzelnen Programme sehr ähneln. Es wurde versucht ähnliche Programmteile wie z.B. Ein- und Ausgabe einheitlich zu gestalten, folglich werden gleiche Programmteile auch nur einmal im Text erklärt.

1. Gauß'sches Eliminationsverfahren

1.1 Grundprinzip

Dem Computer muß zu Beginn erst einmal das Gleichungssystem übergeben werden, auf das das Gauß'sche Eliminationsverfahren angwendet werden soll. Die Befehlsanweisungen sollte man dazu sinnvollerweise in einer Prozedur mit dem Namen "Eingabe" zusammenfassen. Jetzt ist es wieder nützlich, sich das Gleichungssystem in Matrix-Schreibweise vorzustellen. Lediglich Koeffizientenmatrix und den Freigliedervektor muß dem Computer übergeben werden. Es bietet sich an, diese Werte in einem zwei-dimensionalen nx(n+1) Array vom Typ Real abzulegen. In der Spalte n+1 legt man die Freiglieder ab. Diese Feld muß ebenso global definiert sein wie die Dimension n des Gleichungssystems.
Die Eingaberoutine könnte dann wie folgt lauten:

PROCEDURE Eingabe;                        
BEGIN                                     
   Write('Anzahl der Gleichungen: ');     
   ReadLn(n);                             
   FOR i:=1 TO n DO                       
     FOR j:=1 TO n+1 DO                   
     BEGIN                                
       Write('Koeffizient[',i,',',j,'] ');
       ReadLn(Koeffizient[i,j]);          
     END;                                 
END;                                      

Dem Computer ist das Gleichungssystem nun bekannt, der Eliminationsvorgang kann gestartet werden. Die Prozedur "Eliminieren" soll die Befehlsanweisungen dafür in sich vereinen.
Insgesamt benötigt man drei Laufschleifen. Die äußerste Schleife, die k-Schleife, führt die k-Eliminationsstufen und Pivotierungen durch. Die k-Schleife läuft von eins bis n-1, da in einem n-dimensionalen Gleichungssystem n-1 Eliminationsstufen notwendig sind, um dieses in ein gestaffeltes Gleichungsystem zu überführen. Vor jeder Eliminationsstufe muß zunächst der Pivotierungsvorgang durchgeführt werden. Dieser ist unbedingt notwendig, da das Programm sonst eventuell mit "Division by Zero" abbrechen könnte.
Die Pivotierung gestaltet sich ziemlich einfach. Für das Pivotelement nimmt man zu Anfang Null an, sucht dann mit einer Schleife die k-te Spalte nach vom Betrag her größeren Werten ab und ermittelt dann die Zeile des größten Wertes.
Diese Zeile vertauscht man dann in einer anderen Laufschleife mit der k-ten Zeile. Ist das Pivotelement trotzdem null, so muß der Eliminationsvorgang abgebrochen werden, da das Gleichungssystem in diesem Fall keine eindeutige Lösung besitzt.
Erst jetzt kann eliminiert werden. Dazu benötigt man zwei verschachtelte Laufschleifen. Die äußere sei die i-Schleife, sie gibt an, in welcher Zeile gerade eliminiert wird. In dieser wird der Faktor c ermittelt, mit dem dann die Zeile k multipliziert und von der Zeile i subtrahiert wird. Dieser Vorgang wird in der innersten Schleife, der j-Schleife, ausgeführt.
Die Prozedur "Eliminieren" ist damit komplett:

PROCEDURE Eliminieren;                                                  
VAR Pivotelement, Faktor: REAL;                                         
    Pivotzeile, i, j, k: INTEGER;                                       
BEGIN                                                                   
  FOR k:= 1 TO n - 1 DO {* Gesamtelimination}                           
    BEGIN                                                               
      Pivotelement:= 0;                                                 
      Pivotzeile:= k;                                                   
      FOR i:= k TO n DO  {* Pivotelement suchen}                        
        IF Abs(Koeffizient[i, k]) > Pivotelement THEN                   
        BEGIN                                                           
          Pivotelement:= Abs(Koeffizient[i, k]);                        
          Pivotzeile:= i;                                               
        END;                                                            
      IF k <> Pivotzeile THEN {* wenn k=i, Pivotelement bereits richtig}
        FOR j:= k TO n + 1 DO {* Zeilen vertauschen}                    
          Exchange(Koeffizient[k, j], Koeffizient[Pivotzeile, j]);      
                                                                        
      IF Koeffizient[k, k] = 0 THEN Abbruch;                            
      FOR i:= k + 1 TO n DO {* Elimination auf Stufe k}                 
        BEGIN                                                           
          Faktor:= Koeffizient[i, k] / Koeffizient[k, k];               
          FOR j:= k TO n + 1 DO                                         
            Koeffizient[i,j]:= Koeffizient[i,j]-Faktor*Koeffizient[k,j];
        END;                                                            
    END;                                                                
END;