4
0 2 3 4 49
1 0 3 4 45
1 2 0 4 36
1 2 3 0 23

5
2 -2  2 -7  6 -4
7 -3 -2  7  2 11
2  2 -1  1  4  9
9  8 -2  2 -2 21
4  8 -3  3 -1 16

// Program rozwiązuje układ
// równań liniowych
// o n niewiadomych
// za pomocą metody eliminacji
// Gaussa-Crouta.
//----------------------------
//   (C)2006 mgr J.Wałaszek

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>
#include <cstdlib>

using namespace std;

// dokładność porównania z zerem
const double EPS = 0.0000000001;
// maksymalna ilość równań w układzie
const int    MAXEQ = 100;

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
bool GCEliminujX(int n,
                 double AB[][MAXEQ+1],
                 int WK[])
{
  int    i,j,k;
  double m;

  for(i = 0; i < n - 1; i++)
  {
    for(k = i, j = i + 1; j < n; j++)
      if(fabs(AB[i][WK[k]]) <
         fabs(AB[i][WK[j]])) k = j;
    swap(WK[k],WK[i]);
    if(fabs(AB[i][WK[i]]) < EPS)
      return false;
    for(j = i + 1; j < n; j++)
    {
      m = -AB[j][WK[i]] / AB[i][WK[i]];
      for(k = i + 1; k <= n; k++)
        AB[j][WK[k]] += m * AB[i][WK[k]];
    }
  }
  return true;
}

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez funkcję
// Eliminuj_X(). Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
bool GCObliczX(int n,
               double X[],
               double AB[][MAXEQ+1],
               int WK[])
{
  int    i,j;
  double s;

  for(i = n - 1; i >= 0; i--)
  {
    if(fabs(AB[i][WK[i]]) < EPS)
      return false;
    s = AB[i][n];
    for(j = n - 1; j > i; j--)
      s -= AB[i][WK[j]] * X[WK[j]];
    X[WK[i]] = s / AB[i][WK[i]];
  }
  return true;
}

//---------------
// Program główny
//---------------

int main()
{
  ifstream fin;
  ofstream fout;
  int i,j,n,WK[MAXEQ+1];
  double AB[MAXEQ][MAXEQ+1], X[MAXEQ];

  cout << setprecision(5)
       << fixed
       << "  Uklad rownan liniowych\n"
       << "   metoda Gaussa-Crouta\n"
          "  ----------------------\n"
          "(C)2006 mgr Jerzy Walaszek\n\n";

  // Dane dla programu odczytujemy
  // z pliku tekstowego o nazwie
  // in.txt, który musi się znajdować
  // w tym samym katalogu co program
  // Pierwszy wiersz pliku powinien
  // zawierać liczbę n. Następne
  // n kolejnych wierszy powinno
  // zawierać współczynniki ai dla
  // tego wiersza, a na końcu
  // współczynnik bi. Kolejne
  // współczynniki oddzielone są od
  // siebie przynajmniej jedną spacją.
  fin.open("in.txt");
  fin >> n;
  if(n <= MAXEQ)
  {
    for(i = 0; i < n; i++)
    {
      WK[i] = i;
      for(j = 0; j <= n; j++)
        fin >> AB[i][j];
    }
    WK[n] = n;
    fin.close();

    // Dokonujemy eliminacji oraz
    // obliczania niewiadomych x

    cout << "Wyniki:\n\n";

    if(GCEliminujX(n,AB,WK) &&
       GCObliczX(n,X,AB,WK))
    {
      fout.open("out.txt");
      for(i = 0; i < n; i++)
      {
        cout << "x"
             << i + 1
             << " = "
             << setw(12)
             << X[i] << endl;
        fout << X[i] << endl;
      }
      fout.close();
    }
    else
      cout << "Rozwiazanie ukladu "
              "rownan nie powiodlo "
              "sie\n";
  }
  else
  {
    fin.close();
    cout << "Zbyt wiele rownan!\n";
  }
  cout << endl;
  system("pause");
  return 0;
}

// Program rozwiązuje układ
// równań liniowych
// o n niewiadomych
// za pomocą metody eliminacji
// Gaussa-Crouta.
//----------------------------
//   (C)2006 mgr J.Wałaszek

program mzfl5;

const
  // dokładność porównania z zerem
  EPS   = 0.0000000001;
  // maksymalna ilość równań w układzie
  MAXEQ = 100;

type
  xwektor = array[1..MAXEQ]
    of double;
  kwektor = array[1..MAXEQ + 1]
    of integer;
  macierz = array[1..MAXEQ,1..MAXEQ + 1]
    of double;

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function Eliminuj_X(n : integer;
                    var AB : macierz;
                    var WK : kwektor)
                    : boolean;
var
  i,j,k,tmp : integer;
  m         : double;
begin
  for i := 1 to n - 1 do
  begin
    k := i;
    for j := i + 1 to n do
      if abs(AB[i,WK[k]]) <
         abs(AB[i,WK[j]]) then k := j;
    tmp := WK[k];
    WK[k] := WK[i];
    WK[i] := tmp;
    if abs(AB[i,WK[i]]) < EPS then
    begin
      Result := false;
      exit;
    end;
    for j := i + 1 to n do
    begin
      m := -AB[j,WK[i]] / AB[i,WK[i]];
      for k := i + 1 to n + 1 do
        AB[j,WK[k]] := AB[j,WK[k]] +
                       m * AB[i,WK[k]];
    end;
  end;
  Result := true;
end;

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez funkcję
// Eliminuj_X(). Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function Oblicz_X(n : integer;
                  var X : xwektor;
                  var AB : macierz;
                  var WK : kwektor)
                  : boolean;
var
  i,j : integer;
  s   : double;
begin
  for i := n downto 1 do
  begin
    if abs(AB[i,WK[i]]) < EPS then
    begin
      Result := false;
      exit;
    end;
    s := AB[i,n + 1];
    for j := n downto i + 1 do
      s := s - AB[i,WK[j]] * X[WK[j]];
    X[WK[i]] := s / AB[i,WK[i]];
  end;
  Result := true;
end;

//---------------
// Program główny
//---------------

var
  f     : Text;
  i,j,n : integer;
  AB    : macierz;
  X     : xwektor;
  WK    : kwektor;

begin
  writeln('  Uklad rownan liniowych');
  writeln('   metoda Gaussa-Crouta');
  writeln('  ----------------------');
  writeln('(C)2006 mgr Jerzy Walaszek');
  writeln;

  // Dane dla programu odczytujemy
  // z pliku tekstowego o nazwie
  // in.txt, który musi się znajdować
  // w tym samym katalogu co program
  // Pierwszy wiersz pliku powinien
  // zawierać liczbę n. Następne
  // n kolejnych wierszy powinno
  // zawierać współczynniki ai dla
  // tego wiersza, a na końcu
  // współczynnik bi. Kolejne
  // współczynniki oddzielone są od
  // siebie przynajmniej jedną spacją.
  assignfile(f,'in.txt');
  reset(f);
  readln(f,n);
  if n <= MAXEQ then
  begin
    for i := 1 to n do
    begin
      WK[i] := i;
      for j := 1 to n + 1 do
        read(f,AB[i,j]);
    end;
    WK[n + 1] := n + 1;
    closefile(f);

    // Dokonujemy eliminacji oraz
    // obliczania niewiadomych x
    writeln('Wyniki:');
    writeln;
    if Eliminuj_X(n,AB,WK) and
       Oblicz_X(n,X,AB,WK) then
    begin
      assignfile(f,'out.txt');
      rewrite(f);
      for i := 1 to n do
      begin
        writeln('x',i,' = ',X[i]:12:5);
        writeln(f,X[i]);
      end;
      closefile(f);
    end
    else
    begin
      write('Rozwiazanie ukladu ');
      write('rownan nie powiodlo ');
      writeln('sie');
    end;
  end
  else
  begin
    writeln('Zbyt wiele rownan!');
    closefile(f);
  end;
  writeln;
  writeln('Nacisnij Enter...');
  readln;
end.

' Program rozwiązuje układ
' równań liniowych o n
' niewiadomych za pomocą
' metody eliminacji
' Gaussa-Crouta.
'-------------------------
' (C)2006 mgr J.Wałaszek

Declare Function _
          EliminujX(n As Integer, _
                    AB() As Double, _
                    WK() As Integer) _
                    As Integer
Declare Function _
          ObliczX(n As Integer, _
                  X() As Double, _
                  AB() As Double, _
                  WK() As Integer) _
                  As Integer

' dokładność porównania z zerem
Const EPS As double = 0.0000000001
' maksymalna ilość równań w układzie
Const MAXEQ As Integer = 100

'---------------
' Program główny
'---------------

Dim As Integer i, j, n, WK(MAXEQ)
Dim As Double AB(MAXEQ - 1, MAXEQ), _
              X(MAXEQ - 1)

Print "  Uklad rownan liniowych"
Print "   metoda Gaussa-Crouta"
Print "  ----------------------"
Print "'(C)2006 mgr Jerzy Walaszek"
Print
  
' Dane dla programu odczytujemy
' z pliku tekstowego o nazwie
' in.txt, który musi się znajdować
' w tym samym katalogu co program.
' Pierwszy wiersz pliku powinien
' zawierać liczbę n. Następne
' n kolejnych wierszy powinno
' zawierać współczynniki ai dla
' tego wiersza, a na końcu
' współczynnik bi. Kolejne
' współczynniki oddzielone są od
' siebie przynajmniej jedną spacją.

Open "in.txt" For Input As #1
Input #1, n
If n <= MAXEQ Then
   For i = 0 To n - 1
      WK(i) = i
      For j = 0 To n
        Input #1, AB(i, j)
      Next
   Next
   WK(n) = n
   Close #1

   ' Dokonujemy eliminacji oraz
   ' obliczania niewiadomych x

   Print "Wyniki:"
   Print

   If EliminujX(n, AB(), WK()) And _
      ObliczX(n, X(), AB(), WK()) Then
      Open "out.txt" For Output As #1

      ' Wypisujemy wyniki do okna
      ' konsoli oraz do pliku out.txt
      For i = 0 To n - 1
         Print _
           Using "x## = ######.#####"; _
           i + 1; X(i)
         Print #1, _
           Using "x## = ######.#####"; _
           i + 1; X(i)
      Next
      Close #1
   Else
      Print "Rozwiazanie ukladu rownan ";
      Print "nie powiodlo sie"
   End If
Else
   Print "Zbyt wiele rownan!"
   Close #1
End If
Print
Print "Nacisnij Enter..."
Sleep
End

' Funkcja dokonująca eliminacji
' niewiadomych. Jeśli operacja
' się powiedzie, zwraca true.
' Inaczej zwraca false.
Function EliminujX(n As Integer, _
                   AB() As Double, _
                   WK() As Integer) _
                   As Integer
  Dim As Integer i, j, k
  Dim m As Double

  For i = 0 To n - 2
    k = i
    For j = i + 1 To n - 1
      If Abs(AB(i, WK(k))) < _
         Abs(AB(i, WK(j))) Then k = j
    Next
    Swap WK(k), WK(i)
    If Abs(AB(i, WK(i))) < EPS Then _
      Return 0
    For j = i + 1 To n - 1
      m = -AB(j, WK(i)) / AB(i, WK(i))
      For k = i + 1 To n
        AB(j, WK(k)) += m * AB(i, WK(k))
      Next
    Next
  Next
  Return 1
End Function

' Funkcja oblicza kolejne
' niewiadome x z macierzy AB
' przetworzonej przez funkcję
' Eliminuj_X(). Jeśli operacja
' się powiedzie, zwraca true.
' Inaczej zwraca false.
Function ObliczX(n As Integer, _
                 X() As Double, _
                 AB() As Double, _
                 WK() As Integer) _
                 As Integer
  Dim As Integer i, j
  Dim s As Double

  For i = n - 1 To 0 Step -1
    If Abs(AB(i, WK(i))) < EPS Then _
      Return 0
    s = AB(i, n)
    For j = n - 1 To i + 1 Step -1
      s -= AB(i, WK(j)) * X(WK(j))
    Next
    X(WK(i)) = s / AB(i, WK(i))
  Next
  Return 1
End Function

<html>
  <head>
  </head>
  <body>
<div style="overflow-x: auto;"
     align="center">
  <table
  border="0"
  cellpadding="4"
  style="border-collapse:
         collapse">
    <tr>
      <td nowrap>
        <form
        name="frmbincode"
        style="text-align: center;
               background-color:
               #E7E7DA">
          <big><b>
          Demonstracja rozwiązywania<br>
          układu równań za pomocą<br>
          Eliminacji Gaussa-Crouta</b>
          </big><br>
          <br>
          &nbsp;&nbsp;
          (C)2026
          mgr Jerzy Wałaszek
          I LO w Tarnowie
          &nbsp;&nbsp;
          <hr>
          Tutaj wprowadź wiersze<br>
          ze współczynnikami<br>
          układu równań:<br>
          <br>
          <textarea
          rows="9"
          name="input"
          cols="50">
5
2 -2 2 -7 6 -4
7 -3 -2 7 2 11
2 2 -1 1 4 9
9 8 -2 2 -2 21
4 8 -3 3 -1 16
          </textarea>
          <hr>
          <input
          type="button"
          value="Licz"
          name="B1"
          onclick="main()">
          <hr>
          <b>Wyniki:</b>
          <div
          id="out"
          align="center">.</div>
        </form>
      </td>
    </tr>
  </table>
</div>

<script language=javascript>

// Program rozwiązuje układ
// równań liniowych o n niewiadomych
// za pomocą metody eliminacji
// Gaussa-Crouta.
//----------------------------------
// (C)2006 mgr J.Wałaszek
// I LO w Tarnowie

// dokładność porównania z zerem
var EPS   = 0.0000000001
// maksymalna ilość równań w układzie
var MAXEQ = 100

// Funkcja dokonująca eliminacji
// niewiadomych. Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function GCEliminujX(n, AB, WK)
{
  var i,j,k,m,tmp

  for(i = 0; i < n - 1; i++)
  {
    for(k = i, j = i + 1; j < n; j++)
      if(Math.abs(AB[i][WK[k]]) <
         Math.abs(AB[i][WK[j]])) k = j
    tmp = WK[k]
    WK[k] = WK[i]
    WK[i] = tmp
    if(Math.abs(AB[i][WK[i]]) < EPS)
      return false;
    for(j = i + 1; j < n; j++)
    {
      m = -AB[j][WK[i]] / AB[i][WK[i]]
      for(k = i + 1; k <= n; k++)
        AB[j][WK[k]] += m * AB[i][WK[k]]
    }
  }
  return true
}

// Funkcja oblicza kolejne
// niewiadome x z macierzy AB
// przetworzonej przez funkcję
// Eliminuj_X(). Jeśli operacja
// się powiedzie, zwraca true.
// Inaczej zwraca false.
function GCObliczX(n, X, AB, WK)
{
  var i,j,s

  for(i = n - 1; i >= 0; i--)
  {
    if(Math.abs(AB[i][WK[i]]) < EPS)
      return false
    s = AB[i][n]
    for(j = n - 1; j > i; j--)
      s -= AB[i][WK[j]] * X[WK[j]]
    X[WK[i]] = s / AB[i][WK[i]]
  }
  return true;
}

//---------------
// Program główny
//---------------

function main()
{
  var i,j,n,s,t,z
  var AB = new Array(MAXEQ)
  var X  = new Array(MAXEQ)
  var WK = new Array(MAXEQ)

  // Dane dla programu odczytujemy
  // z pola tekstowego. Pierwszy
  // wiersz pola powinien zawierać
  // liczbę n. Następne n kolejnych
  // wierszy powinno zawierać
  // współczynniki ai dla tego
  // wiersza, a na końcu
  // współczynnik bi. Kolejne
  // współczynniki oddzielone
  // są od siebie przynajmniej
  // jedną spacją.
  t = "<font color=red>" +
      "<b>Złe dane</b></font>"
  s = document.frmbincode.input.value
  if(s.length > 0)
  {
    // Odczytujemy współczynniki
    // z pola tekstowego formularza
    while((j = s.indexOf('\n')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while((j = s.indexOf('\r')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while((j = s.indexOf('\t')) != -1)
      s = s.substring(0,j) + " " +
          s.substring(j + 1,s.length)
    while(s.length > 0 &&
         (s.charAt(0) == " "))
      s = s.substring(1,s.length)
    while(s.length > 0 &&
         (s.charAt(s.length-1) == " "))
      s = s.substring(0,s.length - 1)
    while(s.length > 0 &&
         ((j = s.indexOf("  ")) != -1))
      s = s.substring(0,j) +
          s.substring(j+1,s.length)
    s = s.split(' ')
    if(s.length > 0)
    {
      n = parseInt(s[0])
      if((!isNaN(n)) &&
        (s.length >= n * (n + 1) + 1) &&
        (n <= MAXEQ))
      {
        k = 1
        z = true
        for(i = 0; i < n; i++)
        {
          AB[i] = new Array(n + 1)
          WK[i] = i
          for(j = 0; j <= n; j++)
            z = z && !isNaN(AB[i][j] =
                parseFloat(s[k++]))
        }
        WK[n] = n
        if(z)
        {
          // Dokonujemy eliminacji oraz
          // obliczania niewiadomych x
          t = "<table border='0' " +
              "cellpadding='4' " +
              "style='border-collapse: " +
              "collapse'>" +
              "<tr><td nowrap>"

          if(GCEliminujX(n,AB,WK) &&
             GCObliczX(n,X,AB,WK))
            for(i = 0; i < n; i++)
              t += "x<sub>" +
                   (i + 1) + "</sub> = " +
                   X[i] + "<br>"
          else
            t += "<font color=red>" +
                 "<b>Rozwiązanie układu " +
                 "równań nie powiodło się" +
                 "</b></font>"
          t += "</td></tr></table>"
        }
      }
    }
  }
  document.getElementById("out").innerHTML = t
}
</script>
  </body>
</html>