Równania

// Macierze
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0061
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

// Definicja klasy,
// może być w pliku
// nagłówkowym
//-----------------

#ifndef _matrix_class
  #define _matrix_class

template <class T>
          class matrix
{
  private:
    // Wyrazy macierzy
    T * A;
  public:
    // Stopień macierzy
    int n;
    // Konstruktor
    matrix();
    // Konstruktor
    matrix(int nn);
    // Destruktor
    ~matrix();
    T  getv(int r, int c);
    void setv(int r, int c, T v);
    // ustawia elementy
    // przekątnej na 1
    void set1();
    // Oblicza wyznacznik
    T det();
};

// Konstruktor #1 tworzy
// macierz ze strumienia cin
//--------------------------
template <class T>
         matrix<T>::matrix()
{
  // Stopień macierzy
  cin >> n;
  // wielkość macierzy
  int nn = n * n;
  // Rezerwujemy pamięć
  // na macierz n x n
  A = new T [nn];

  // Wczytujemy wyrazy macierzy
  for(int i = 0; i < nn; i++)
    cin >> A[i];
}

// Konstruktor #2 tworzy macierz
// stopnia n i wypełnia ją zerami
//-------------------------------
template <class T>
         matrix<T>::matrix(int nn)
{
  // Stopień macierzy
  n = nn;
  nn = n * n;
  // Rezerwujemy pamięć
  // na macierz n x n
  A = new T [nn];

  for(int i = 0; i < nn; i++)
    A[i] = (T)0;
}

// Destruktor usuwa macierz
// i zwraca zajętą przez
// nią pamięć do systemu
//-------------------------
template <class T>
         matrix<T>::~matrix()
{
  delete [] A;
}

// Zwraca wartość elementu
// r - numer wiersza
// c - numer kolumny
//-------------------------
template <class T>
         T matrix<T>
         ::getv(int r, int c)
{
  return A[r * n + c];
}

// Ustawia wartość elementu
// r - numer wiersza
// c - numer kolumny
// v - wartość elementu
//-------------------------
template <class T>
         void matrix<T>
         ::setv(int r, int c, T v)
{
  A[r * n + c] = v;
}

// Ustawia przekatną na 1
//-----------------------
template <class T>
         void matrix<T>::set1()
{
  for(int i = 0; i < n; i++)
    A[i * n + i] = 1;
}

// Oblicza wyznacznik
// macierzy
template <class T>
         T matrix<T>::det()
{
  matrix<T> L(n);
  matrix<T> U(n);
  L.set1();
  int i,j,k;
  T sc;
  for(j = 0; j < n; j++)
  {
    for(i = 0; i <= j; i++)
    {
      sc = (T)0;
      for(k = 0; k < i; k++)
        sc += L.getv(i,k)
              * U.getv(k,j);
      U.setv(i,j,getv(i,j) - sc);
    }
    for(i = j + 1; i < n; i++)
    {
      sc = (T)0;
      for(k = 0; k < j; k++)
        sc += L.getv(i,k)
              * U.getv(k,j);
      if(U.getv(j,j))
        L.setv(i,j,(getv(i,j) - sc)
               / U.getv(j,j));
    }
  }
  sc = (T)1;
  for(i = 0; i < n; i++)
    sc *= U.getv(i,i);
  return sc;
}

#endif // _matrix_class

// Program główny
//---------------
int main()
{

  // Wczytujemy dane
  // dla macierzy

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << setprecision(2)
       << fixed;

  cout
  << "Wpisz dane dla macierzy:\n\n";

  matrix<double> A;

  cout
  << "\nWyznacznik macierzy metodą"
     "rozkładu LU Doolitle'a\n"
     "--------------------------"
     "----------------------\n\n";
  for(int i = 0; i < A.n; i++)
  {
    for(int j = 0; j < A.n; j++)
      cout << setw(8)
           << A.getv(i,j);
    cout << endl;
  }
  cout << "\n\nWyznacznik = "
       << A.det();

  cout << endl << endl;
  system("pause");
  return 0;
}

// Macierze
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0062
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

// Definicja klasy,
// może być w pliku
// nagłówkowym
//-----------------

#ifndef _matrix_class
  #define _matrix_class

template <class T>
         class matrix
{
  private:
    // Wyrazy macierzy
    T * A;
    T EPS;
  public:
    // Stopień macierzy
    int n;
    // Wielkość macierzy
    int s;
    // Błąd obliczenia wyznacznika
    bool error;
    matrix();  // Konstruktor
    ~matrix(); // Destruktor
    T  getv(int r, int c);
    void setv(int r, int c, T v);
    // Oblicza wyznacznik
    T det();
};

// Konstruktor tworzy macierz
// ze strumienia cin
//---------------------------
template <class T>
         matrix<T>::matrix()
{
  error = false;
  EPS = (T)0.000000001;

  // Stopień macierzy
  cin >> n;

  // Wielkość macierzy
  s = n * n;

  // Rezerwujemy pamięć
  // na macierz n x n
  A = new T [s];

  // Wczytujemy wyrazy
  // macierzy
  for(int i = 0; i < s; i++)
    cin >> A[i];
}

// Destruktor usuwa macierz
// i zwraca zajętą przez
// nią pamięć
//-------------------------
template <class T>
         matrix<T>::~matrix()
{
  delete [] A;
}

// Zwraca wartość elementu
// r - numer wiersza
// c - numer kolumny
//-------------------------
template <class T>
         T matrix<T>
         ::getv(int r, int c)
{
  return A[r * n + c];
}

// Ustawia wartość elementu
// r - numer wiersza
// c - numer kolumny
// v - wartość elementu
//-------------------------
template <class T>
         void matrix<T>
         ::setv(int r, int c, T v)
{
  A[r * n + c] = v;
}

// Oblicza wyznacznik
// macierzy
template <class T>
         T matrix<T>::det()
{
  int i,j,k;
  T sc;
  error = false;
  for(j = 0; j < n; j++)
  {
    if((getv(j,j) > - EPS) &&
       (getv(j,j) < EPS))
    {
      // Błąd w obliczaniu
      // wyznacznika
      error = true;
      return 0;
    }
    for(i = 0; i <= j; i++)
    {
      sc = (T)0;
      for(k = 0; k < i; k++)
        sc += getv(i,k)* getv(k,j);
      setv(i,j,getv(i,j) - sc);
    }
    for(i = j + 1; i < n; i++)
    {
      sc = (T)0;
      for(k = 0; k < j; k++)
        sc += getv(i,k) * getv(k,j);
      setv(i,j,(getv(i,j) - sc) /
           getv(j,j));
    }
  }
  sc = (T)1;
  for(i = 0; i < n; i++)
    sc *= getv(i,i);
  return sc;
}

#endif // _matrix_class

// Program główny
//---------------
int main()
{
  // Wczytujemy dane
  // dla macierzy

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << setprecision(2)
       << fixed;

  cout << "Wpisz dane dla macierzy:"
       << endl << endl;

  matrix<double> A;

  cout << endl
       << "Wyznacznik macierzy metodą "
          "rozkładu LU Doolitle'a "
          "w miejscu\n"
          "---------------------------"
          "-----------------------"
          "---------\n\n";
  for(int i = 0; i < A.n; i++)
  {
    for(int j = 0; j < A.n; j++)
      cout << setw(8) << A.getv(i,j);
    cout << endl;
  }

  cout << "\nWyznacznik = " << A.det();

  if(A.error)
    cout << " - BŁĄD W OBLICZENIACH !!!";

  cout << endl << endl;
  system("pause");
  return 0;
}

// Macierze
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0063
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

// Definicja klasy,
// może być w pliku
// nagłówkowym
//-----------------

#ifndef _matrix_class
  #define _matrix_class

template <class T>
         class matrix
{
  private:
    // Wyrazy macierzy
    T * A;
    T EPS;
  public:
    // Stopień macierzy
    int n;
    // Błąd obliczenia
    // wyznacznika
    bool error;
    // Konstruktor
    matrix();
    // Destruktor
    ~matrix();
    T getv(int r, int c);
    void setv(int r, int c, T v);
    // Oblicza wyznacznik
    T det();
};

// Konstruktor tworzy
// macierz ze strumienia
// wejścia cin
//----------------------
template <class T>
         matrix<T>::matrix()
{
  // Zerujemy błąd
  error = false;

  // Dokładność
  EPS = (T)0.000000001;

  // Stopień macierzy
  cin >> n;

  // Rozmiar macierzy
  int nn = n * n;

  // Rezerwujemy pamięć
  // na macierz n x n
  A = new T [nn];

  // Wczytujemy kolejne
  // wyrazy macierzy
  for(int i = 0; i < nn; i++)
    cin >> A[i];
}

// Destruktor usuwa macierz
// i zwraca zajętą przez
// nią pamięć
//-------------------------
template <class T>
         matrix<T>::~matrix()
{
  delete [] A;
}

// Zwraca wartość elementu
// r - numer wiersza
// c - numer kolumny
//-------------------------
template <class T>
         T matrix<T>
         ::getv(int r, int c)
{
  return A[r * n + c];
}

// Ustawia wartość elementu
// r - numer wiersza
// c - numer kolumny
// v - wartość elementu
//-------------------------
template <class T>
         void matrix<T>
         ::setv(int r, int c,
                T v)
{
  A[r * n + c] = v;
}

// Oblicza wyznacznik
// macierzy
template <class T>
         T matrix<T>::det()
{
  int i,j,k;
  T sc, akk;

  for(k = 0; k < n - 1; k++)
  {
    // Dzielnik
    akk = getv(k,k);
    if((akk > -EPS) && (akk < EPS))
    {
      error = true;
      return 0;
    }

    // Normalizujemy kolumnę
    for(i = k + 1; i < n; i++)
      setv(i,k,getv(i,k) / akk);

    // Modyfikujemy podmacierz
    for(i = k + 1; i < n; i++)
      for(j = k + 1; j < n; j++)
        setv(i,j,
             getv(i,j) - getv(i,k)
             * getv(k,j));
  }

  // Obliczamy wyznacznik;
  sc = getv(0,0);
  for(k = 1; k < n; k++)
    sc *= getv(k,k);
  return sc;
}

#endif // _matrix_class

// Program główny
//---------------
int main()
{
  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  // Wczytujemy dane
  // dla macierzy
  cout << setprecision(2)
       << fixed;
  cout << "Wpisz dane dla macierzy:"
       << endl << endl;

  matrix<double> A;

  cout << endl
       << "Wyznacznik macierzy "
          "metodą normalizacji "
          "kolumn\n"
          "--------------------"
          "--------------------"
          "------\n\n";
  for(int i = 0; i < A.n; i++)
  {
    for(int j = 0; j < A.n; j++)
      cout << setw(8)<< A.getv(i,j);
    cout << endl;
  }

  cout << endl
       << "Wyznacznik = "
       << A.det();

  if(A.error)
    cout << " - BŁĄD OBLICZENIA !!!";

  cout << endl << endl;
  system("pause");
  return 0;
}

// Macierze
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0064
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

// Definicja klasy,
// może być w pliku
// nagłówkowym
//-----------------

#ifndef _matrix_class
  #define _matrix_class

template <class T>
         class matrix
{
  private:
    // Wyrazy macierzy
    T * A;
    T EPS;
  public:
    // Stopień macierzy
    int n;
    // Błąd obliczania wyznacznika
    bool error;
    matrix();  // Konstruktor
    ~matrix(); // Destruktor
    T getv(int r, int c);
    void setv(int r, int c, T v);
    T absT(T x);
    T det(); // Oblicza wyznacznik
};

// Konstruktor tworzy
// macierz ze strumienia
// wejścia cin
//----------------------
template <class T>
         matrix<T>::matrix()
{
  error = false;
  EPS = (T)0.000000001;

  // Stopień macierzy
  cin >> n;

  // Wielkość macierzy
  int s = n * n;

  // Rezerwujemy pamięć
  // na macierz n x n
  A = new T [s];

  // Wczytujemy wyrazy
  // macierzy
  for(int i = 0; i < s; i++)
    cin >> A[i];
}

// Destruktor usuwa macierz
// i zwraca zajętą przez
// nią pamięć
//-------------------------
template <class T>
         matrix<T>::~matrix()
{
  delete [] A;
}

// Zwraca wartość elementu
// r - numer wiersza
// c - numer kolumny
//-------------------------
template <class T>
         T matrix<T>
         ::getv(int r, int c)
{
  return A[r * n + c];
}

// Ustawia wartość elementu
// r - numer wiersza
// c - numer kolumny
// v - wartość elementu
//-------------------------
template <class T>
         void matrix<T>
         ::setv(int r, int c, T v)
{
  A[r * n + c] = v;
}

template <class T>
         T matrix<T>::absT(T x)
{
  if(x < (T)0)
    x = - x;
  return x;
}

// Oblicza wyznacznik macierzy
template <class T>
         T matrix<T>::det()
{
  int i, j, k, * W, md, maxw;
  T sc, akk, maxe;

  // Mnożnik korekcyjny
  // dla wyznacznika
  md = 1;

  // Tworzymy wektor wierszowy
  W = new int [n];

  // Inicjujemy wektor wierszowy
  // numerami wierszy
  for(i = 0; i < n; i++)
    W[i] = i;

  // Rozkład LU
  for(k = 0; k < n; k++)
  {
    // numer wiersza
    // z elementem max
    maxw = k;
    maxe = absT(getv(W[k],k));

    // Szukamy elementu max
    for(i = k + 1; i < n; i++)
      if(absT(getv(W[i],k)) > maxe)
      {
        maxw = i;
        maxe = absT(getv(W[i],k));
      }

     // Jeśli max jest zero,
     // to macierz jest
     // zdegenerowana
     if(maxe <= EPS)
     {
       error = true;
       delete [] W;
       return 0;
     }

     // Jeśli max nie leży
     // na przekątnej,
     // zamieniamy wiersze
     if(maxw != k)
     {
       // Modyfikujemy mnożnik
       md = -md;
       swap(W[k], W[maxw]);
     }

     // Dzielnik
     akk = getv(W[k],k);

     // Normalizujemy kolumnę
     for(i = k + 1; i < n; i++)
        setv(W[i],k,getv(W[i],k)/akk);

     // Modyfikujemy podmacierz
     for(i = k + 1; i < n; i++)
       for(j = k + 1; j < n; j++)
         setv(W[i],j,getv(W[i],j)
              -getv(W[i],k)
              *getv(W[k],j));
  }

  // Obliczamy wyznacznik;
  sc = md;
  for(k = 0; k < n; k++)
    sc *= getv(W[k],k);
  delete [] W;
  return sc;
}

#endif // _matrix_class

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

int main()
{
  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << setprecision(2)
       << fixed;

  // Wczytujemy dane dla macierzy
  cout << "Wpisz dane dla macierzy:"
       << endl << endl;

  matrix<double> A;

  cout
  << endl
  << "Wyznacznik metodą LU "
     "z częściowym wyborem "
     "elementu głównego\n"
     "---------------------"
     "---------------------"
     "-----------------\n\n";

  for(int i = 0; i < A.n; i++)
  {
    for(int j = 0; j < A.n; j++)
      cout << setw(8)<< A.getv(i,j);
    cout << endl;
  }

  cout << endl
       << "Wyznacznik = "
       << A.det();

  if(A.error)
    cout
    << " - BŁĄD W OBLICZENIACH !!!";

  cout << endl << endl;
  system("pause");
  return 0;
}