Gaußalgorithmus

Die Vorwärtselimination im Gaußalgorithmus erfordert ca. , die Rücksubstitution ca. Operationen.

program Gauss(input, output);

    {Gauss-Elimintation ohne Pivotisierung}
    
    uses
        stdfile;
    
    const
        MaxArray = 32;
        
    var
        n:       integer;
        a:       array [1..MaxArray, 1..MaxArray] of double;
        c, x:    array [1..MaxArray] of double;
        i, j, k: integer;
        sum:     double;
        factor:  double;
                
    procedure init;
        var
            fName: string;
            f:     text;
            t:     double;
            i:     integer;
        begin {init}
            writeln('Gauss-Elimination ohne Pivotisierung');
            writeln;
            writeln('In welcher Datei stehen Matrix und Loesungsvektor?');
            writeln('(In gauss.dat liegt ein Beispiel.)');
            readln(fName);
            if StdOpen(f, fName) then begin
                if not StdRead(f, t) then begin
                    writeln('Kann Dimension nicht lesen.');
                    halt
                end; {if}
                if t > MaxArray then begin
                    writeln('Dimension zu gross (groesser als ', MaxArray,
                        ').');
                    halt
                end; {if}
                n := round(t);
                for i := 1 to n do begin
                    if not StdReadn(f, n, @a[i, 1]) then begin
                        writeln('Fehler beim Lesen der ', i, '-ten Zeile.');
                        halt
                    end {if}
                end; {for}
                if not StdReadn(f, n, @c[1]) then begin
                    writeln('Fehler beim Lesen des Loesungsvektors.');
                    halt
                end; {if}
                writeln;
                close(f)
            end else begin {if}
                writeln('Kann Datei "', fName, '" nicht oeffnen.');
                halt
            end {if}
        end; {init}

    procedure result;
        var
            i: integer;
        begin {result}
            writeln('Das Ergebnis lautet');
            writeln;
            for i := 1 to n do begin
                writeln(x[i]:7:3)
            end {for}
        end; {result}

    begin {Gauss}
        init;
        {Vorwaertselimination}
        for k := 1 to n - 1 do begin
            for i := k + 1 to n do begin
                {Hier mue3te die Pivotisierung kommen}
                if a[k,k] = 0 then begin
                    writeln('Matrix muss pivotisiert werden.');
                    halt
                end; {if}
                factor := a[i, k] / a[k, k];
                for j := k + 1 to n do begin
                    a[i, j] := a[i, j] - factor * a[k, j]
                end; {for}
                c[i] := c[i] - factor * c[k]
            end {for}
        end; {for} 
        {Rueckwaertsubstitution}
        x[n] := c[n] / a[n, n];
        for i := n - 1 downto 1 do begin
            sum := 0;
            for j := i + 1 to n do begin
                sum := sum + a[i, j] * x[j]
            end; {for}
            x[i] := (c[i] - sum) / a[i, i]
        end; {for}
        result     
    end. {Gauss}