Obliczanie wyznacznika macierzy

numer wiersza = 2

// Program wylicza wyznacznik macierzy w sposób
// rekurencyjny wykorzystując regułę Laplace'a.
//---------------------------------------------
// (C)2006 mgr J.Wałaszek       I LO w Tarnowie

program mzfl3;

type
  kwektor = array[1..8] of integer;
  macierz = array[1..8,1..8] of double;

// Rekurencyjna funkcja obliczania wyznacznika
//--------------------------------------------

function det(stopien, wiersz : integer;
             var wk : kwektor;
             var A  : macierz) : extended;
var
  i,j,k,m : integer;
  kolumny : kwektor; // wektor kolumn dla podmacierzy
begin
  if stopien = 1 then
    Result := A[wiersz,wk[1]]
  else
  begin
    Result := 0; m := 1;
    for i := 1 to stopien do
    begin
      k := 1;
      for j := 1 to stopien - 1 do
      begin
        if k = i then inc(k);
        kolumny[j] := wk[k];
        inc(k);
      end;
      Result := Result+m*A[wiersz,wk[i]]*det(stopien-1,wiersz+1,kolumny,A);
      m := -m;
    end;
  end;
end;

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

var
  A     : macierz;
  nk    : kwektor; // wektor kolumn
  n,i,j : integer;

begin
  writeln('Demonstracja rekurencyjnego wyliczania wyznacznika macierzy');
  writeln('-----------------------------------------------------------');
  writeln('(C)2006 mgr Jerzy Walaszek                  I LO w Tarnowie');
  writeln;

// Generujemy stopień wyznacznika

  randomize;
  n := 2 + random(7);

// Wypełniamy macierz A losowymi wartościami -99..99
// i wyświetlamy ją w oknie konsoli

  for i := 1 to n do
  begin
    for j := 1 to n do
    begin
      A[i,j] := -99 + random(199);
      write(A[i,j]:4:0);
    end;
    writeln; writeln;
  end;

// Inicjujemy wektor kolumn

  for i := 1 to n do nk[i] := i;

// Wyliczamy wyznacznik i wypisujemy jego wartość

  writeln('det A = ', det(n,1,nk,A):0:0);
  writeln;
  writeln('-----------------------------------------------------------');
  writeln('Koniec. Nacisnij klawisz Enter...');
  readln;
end.

// Program wylicza wyznacznik macierzy w sposób
// rekurencyjny wykorzystując regułę Laplace'a.
//---------------------------------------------
// (C)2006 mgr J.Wałaszek       I LO w Tarnowie

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <time.h>

using namespace std;

// Rekurencyjna funkcja obliczania wyznacznika
//--------------------------------------------

long double det(int stopien, int wiersz, int wk[], double A[][8])
{
  int i,j,k,m;
  int kolumny[8]; // wektor kolumn dla podmacierzy
  long double suma;

  if(stopien == 1)
    return A[wiersz][wk[0]];
  else
  {
    suma = 0; m = 1;
    for(i = 0; i < stopien; i++)
    {
      k = 0;
      for(j = 0; j < stopien - 1; j++)
      {
        if(k == i) k++;
        kolumny[j] = wk[k++];
      }
      suma += m * A[wiersz][wk[i]] * det(stopien - 1, wiersz + 1, kolumny, A);
      m = -m;
    }
  return suma;
  }
}

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

int main()
{
  double A[8][8];  // macierz
  int nk[8];       // wektor kolumn
  int n,i,j;

  cout << setprecision(0)     // 0 cyfr po przecinku
       << fixed;              // format stałoprzecinkowy

  cout << "Demonstracja rekurencyjnego wyliczania wyznacznika macierzy\n"
          "-----------------------------------------------------------\n"
          "(C)2006 mgr Jerzy Walaszek                  I LO w Tarnowie\n\n";

// Generujemy stopień wyznacznika

  srand(time(NULL));
  n = 2 + rand() % 7;

// Wypełniamy macierz A losowymi wartościami -99..99
// i wyświetlamy ją w oknie konsoli

  for(i = 0; i < n; i++)
  {
    for(j = 0; j < n; j++)
    {
      A[i][j] = -99 + rand() % 199;
      cout << setw(4) << A[i][j];
    }
    cout << endl << endl;
  }

// Inicjujemy wektor kolumn

  for(i = 0; i < n; i++) nk[i] = i;

// Wyliczamy wyznacznik i wypisujemy jego wartość

  cout << "det A = " << det(n, 0, nk, A) <<
          "\n-----------------------------------------------------------\n\n";
  system("pause");
  return 0;
}

' Program wylicza wyznacznik macierzy w sposób
' rekurencyjny wykorzystując regułę Laplace"a.
'---------------------------------------------
' (C)2006 mgr J.Wałaszek       I LO w Tarnowie

Declare Function det(stopien As Integer,_
                     wiersz As Integer,_
                     wk() As Integer,_
                     A() As Double) As double

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

dim A(7,7) As double
Dim nk(7) As integer ' wektor kolumn
Dim As integer n,i,j

Print "Demonstracja rekurencyjnego wyliczania wyznacznika macierzy"
Print "-----------------------------------------------------------"
Print "(C)2006 mgr Jerzy Walaszek                  I LO w Tarnowie"
Print

' Generujemy stopień wyznacznika

Randomize
n = 2 + Int(Rnd() * 7)

' Wypełniamy macierz A losowymi wartościami -99..99
' i wyświetlamy ją w oknie konsoli

For i = 0 To n - 1
  For j = 0 To n - 1
     A(i, j) = -99 + Int(Rnd() * 199)
     Print Using "####"; A(i, j);
  Next
  Print
  Print
Next

' Inicjujemy wektor kolumn
For i = 0 To n - 1 : nk(i) = i : Next

' Wyliczamy wyznacznik i wypisujemy jego wartość

Print "det A = "; det(n,0,nk(),A())
Print
Print "-----------------------------------------------------------"
Print "Koniec. Nacisnij klawisz Enter..."

Sleep

End

' Rekurencyjna funkcja obliczania wyznacznika
'--------------------------------------------

Function det(stopien As Integer, wiersz As Integer, wk() As Integer, A() As Double) As Double
    Dim As Integer i, j, k, m
    Dim kolumny(7) As Integer ' wektor kolumn dla podmacierzy
    Dim suma As Double

    If stopien = 1 Then
      return A(wiersz, wk(0))
    Else
      suma = 0 : m = 1
      For i = 0 To stopien - 1
        k = 0
        For j = 0 To stopien - 2
          If k = i Then k += 1
          kolumny(j) = wk(k)
          k += 1
        Next
        suma += m * A(wiersz, wk(i)) * det(stopien - 1, wiersz + 1, kolumny(), A())
        m = -m
      Next
      Return suma
    End If
  End Function

<html>
  <head>
  </head>
  <body>
    <div align="center">
      <form style="BORDER-RIGHT: #ff9933 1px outset;
                   PADDING-RIGHT: 4px;
                   BORDER-TOP: #ff9933 1px outset;
                   PADDING-LEFT: 4px;
                   PADDING-BOTTOM: 1px;
                   BORDER-LEFT: #ff9933 1px outset;
                   PADDING-TOP: 1px;
                   BORDER-BOTTOM: #ff9933 1px outset;
                   BACKGROUND-COLOR: #ffcc66" name="frmbincode">
        <h3 id="out_t" style="TEXT-ALIGN: center">
          Demonstracja rekurencyjnego wyliczania wyznacznika macierzy
        </h3>
        <p style="TEXT-ALIGN: center">
          (C)2006 mgr Jerzy Wałaszek I LO w Tarnowie
        </p>
        <hr>
        <p style="TEXT-ALIGN: center">
          <input type="button" value="Generuj macierz i oblicz wyznacznik"
                 name="B1" onclick="main()">
        </p>
        <div id="output" align="center">&nbsp;</div>
      </form>

<script language=javascript>

// Program wylicza wyznacznik macierzy w sposób
// rekurencyjny wykorzystując regułę Laplace'a.
//---------------------------------------------
// (C)2006 mgr J.Wałaszek I LO w Tarnowie

// Rekurencyjna funkcja obliczania wyznacznika
//--------------------------------------------

function det(stopien, wiersz, wk, A)
{
  var i,j,k,m;
  var kolumny = new Array(8); // wektor kolumn dla podmacierzy
  var suma;

  if(stopien == 1)
    return A[wiersz][wk[0]];
  else
  {
    suma = 0; m = 1;
    for(i = 0; i < stopien; i++)
    {
      k = 0;
      for(j = 0; j < stopien - 1; j++)
      {
        if(k == i) k++;
        kolumny[j] = wk[k++];
      }
      suma += m * A[wiersz][wk[i]] * det(stopien - 1, wiersz + 1, kolumny, A);
      m = -m;
    }
    return suma;
  }
}

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

function main()
{
  var A; // Macierz, której wyznacznik jest liczony przez skrypt
  var nk = new Array(8); // wektor kolumn
  var n,i,j,t;

// Generujemy stopień wyznacznika

  n = 2 + Math.floor(Math.random() * 7);

// Wypełniamy macierz A losowymi wartościami -99..99
// i wyświetlamy ją w oknie konsoli

  A = new Array(n);
  t = "<table border='0' cellpadding='4' style='border-collapse: collapse'>"; 
  for(i = 0; i < n; i++)
  {
    A[i] = new Array(n);
    t += "<tr>";
    for(j = 0; j < n; j++)
    {
      A[i][j] = -99 + Math.floor(Math.random() * 199);
      t += "<td align='right'>" + A[i][j] + "</td>";
    }
    t += "</tr>";
  }
  t += "</table><p style='text-align: center'>";

// Inicjujemy wektor kolumn

  for(i = 0; i < n; i++) nk[i] = i;

// Wyliczamy wyznacznik i wypisujemy jego wartość

  t += "det A = " + det(n, 0, nk, A) + "</p>";
  document.getElementById("output").innerHTML = t;
}

</script> 
    </div>
  </body>
</html>

   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie
©2018 mgr Jerzy Wałaszek