Metody Numeryczne

W matematyce macierz (ang. matrix) jest prostokątną tablicą liczb, którą zwykle przedstawiamy następująco:

Liczby w macierzy ułożone są w poziomych wierszach oraz pionowych kolumnach. Liczba wierszy i liczba kolumn określa rozmiar macierzy (ang. matrix size). Macierze zapisujemy zwykle dużymi literami alfabetu, a w indeksie podajemy ich rozmiar. Liczby w macierzy są jej wyrazami (ang. matrix elements/entries) i posiadają indeksy określające numer wiersza i numer kolumny, w których się znajdują. Wyrazy macierzy zapisujemy małymi literami alfabetu:

Macierz zbudowaną z jednego wiersza lub jednej kolumny nazywamy wektorem (ang. vector matrix). Wektory zapisujemy skrótowo jako:

Macierz o jednakowej liczbie wierszy i kolumn nazywamy macierzą kwadratową (ang. square matrix) :

Wyrazy macierzy o równych numerach wiersza i kolumny nazywamy przekątną główną macierzy (ang. matrix main diagonal) , a liczba wierszy lub kolumn nazywana jest wtedy stopniem tej macierzy. Macierz kwadratowa stopnia czwartego wygląda następująco:

Macierz zerowa (ang. zero matrix lub null matrix) posiada wszystkie elementy zerowe:

Macierz jednostkowa, tożsamościowa, identycznościowa (ang. unit matrix lub identity matrix) jest macierzą kwadratową, której elementy przekątnej głównej są równe 1, a wszystkie pozostałe są równe 0:

Podmacierzą (ang. submatrix) nazywamy macierz, która powstaje z macierzy wyjściowej po usunięciu dowolnej liczby kolumn i wierszy:

do podrozdziału do strony

Macierz w języku C++ jest reprezentowana przez tablicę. Tablicę możemy deklarować statycznie lub dynamicznie. Deklaracja statyczna wymaga znajomości rozmiaru tablicy w momencie tworzenia programu.

Poniższy program deklaruje tablicę o rozmiarze 10×20 i wypełnia ją liczbami przypadkowymi o zakresie od 0 do 99.

C++

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

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

using namespace std;

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

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

  cout <<
  "Tablica statyczna o rozmiarze 10 x 20"
  "\n-----------------------------\n\n";

  // Definicja tablicy statycznej
  unsigned int A[10][20];

  // Indeksy elementów
  unsigned i,j;

  // Inicjujemy generator pseudolosowy
  srand(time(NULL));

  // Tablicę wypełniamy liczbami
  // pseudolosowymi z zakresu 0...99

  // Wiersze
  for(i = 0; i < 10; i++)
    // Kolumny
    for(j = 0; j < 20; j++)
      A[i][j] = rand() % 100;

  // Wyświetlamy wyniki
  for(i = 0; i < 10; i++)
  {
    for(j = 0; j < 20; j++)
      cout << setw(3)<< A[i][j];
    cout << endl; // Koniec wiersza
  }

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

Wynik

Tablica statyczna o rozmiarze 10 x 20
-----------------------------

36 34 35 86 2 27 61 50 55 52 59 4 34 77 98 43 94 59 7 73
15 37 5 96 23 31 90 61 13 13 48 0 74 15 52 46 33 75 14 24
32 39 11 28 43 22 10 37 81 93 12 70 81 18 28 23 47 27 62 39
38 55 60 29 12 30 66 74 52 79 48 98 80 87 25 47 95 3 42 18
76 40 70 87 16 34 20 4 13 47 37 76 51 46 83 5 39 36 37 59
34 89 37 27 2 42 59 29 87 26 35 48 61 30 20 30 33 69 27 66
29 28 68 72 44 71 54 86 86 32 21 21 32 19 95 14 11 62 28 41
71 58 83 73 49 2 36 37 72 0 39 59 44 49 73 95 64 44 58 74
90 62 6 20 1 13 24 82 90 82 52 88 22 59 60 26 67 9 57 85
24 34 66 49 14 35 37 21 84 7 25 66 31 19 81 15 79 5 7 76

Pamiętaj, iż w języku C++ indeksy rozpoczynają się od 0, zatem element A[0][0] jest elementem w pierwszym wierszu i w pierwszej kolumnie macierzy.

W języku Python tablice (listy) są z definicji dynamiczne. Jednakże można zasymulować tworzenie tablicy statycznej, np. tak:

Python (dodatek)

# Macierze
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0050
#---------------------------

from random import randrange

# Program główny
#---------------

print("Tablica o rozmiarze 10 x 20"
      "\n-------------------\n")

# Tworzenie tablicy 10x20
a = [[0 for _ in range(20)]
     for _ in range(10)]

# Tablicę wypełniamy liczbami
# pseudolosowymi z zakresu 0...99

# Wiersze 0..9
for i in range(10):
    # Kolumny 0..19
    for j in range(20):
        a[i][j] = randrange(100)

# Wyświetlamy wyniki
for i in range(10):
    for j in range(20):
        print(f"{a[i][j]:3}",end="")
    print() # Koniec wiersza

print()
input("Naciśnij Enter")

Tablicę dynamiczną można stworzyć na kilka sposobów. Pierwszy z nich polega na zarezerwowaniu odpowiedniego obszaru pamięci i umieszczenie w nim tablicy, Po wykorzystaniu tablicy zarezerwowany dla niej obszar pamięci należy zwolnić.

Drugi program pokazuje, jak to zrobić w języku C++:

C++

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

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

using namespace std;

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

int main()
{
  // Inicjujemy
  // generator pseudolosowy
  srand(time(NULL));

  // Generujemy rozmiar tablicy:
  // n - liczba wierszy:  5...15
  // m - liczba kolumn:  10...20

  int n =  5 + rand() % 11;
  int m = 10 + rand() % 11;

  // Tworzymy wskaźnik
  // do wskaźników liczb
  // całkowitych
  int ** A;

  // Tworzymy dynamicznie
  // obszar na tablicę
  // n wskaźników
  A = new int * [n];

  // Tworzymy dynamiczne
  // tablice dla każdego
  // wiersza
  int i,j;

  for(i = 0; i < n; i++)
    A[i] = new int [m];

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << "Tablica dynamiczna "
       << n << " x " << m << endl
       << "------------------"
       << endl << endl;

  // Tablicę wypełniamy
  // liczbami pseudolosowymi
  // z zakresu 0...99
  for(i = 0; i < n; i++)   // Wiersze
    for(j = 0; j < m; j++) // Kolumny
      A[i][j] = rand()% 100;

  // Wyświetlamy wyniki
  for(i = 0; i < n; i++)
  {
    for(j = 0; j < m; j++)
      cout << setw(3) << A[i][j];
    cout << endl; // Koniec wiersza
  }

  cout << endl;

  // Usuwamy tablice wierszy
  for(i = 0; i < n; i++)
    delete [] A[i];

  // Usuwamy tablicę wskaźników
  delete [] A;

  system("pause");
  return 0;
}

Wynik

Tablica dynamiczna 13 x 20
------------------

 42 47 13 21 47 30 21 11 56 93 81 83 12 49 16 94 98 17 90 58
 77 60 56 56 29 84 51 53 63 53 73 75 60 18 71 73 35 23 50 60
 67 56 67 55  6 76  5  1 83 74 74 78 17 32 37 51  5 37 54 14
 38 25 98 10 47 50 52 98 97 66 48 48 29 30 35 40 48 96 40 29
 61  8 46 80 55 12 25 94 28 10 57 64 16 15 80 61 54  8 88 94
 76 83 34 11 26 87 21 24 41 89 37 19 40 64 33 63 78 94 98 48
 81 39 10  9 99 52 78 50  7 80 76  0 74  8 68 85 10 29 55 72
 42 10 92  9 92  5 95 81 96 46  7 85 53 51 25 43 33 83 21 68
 64 77  3 40 37 42 94 71  4 42 95 69 95 87 14 36 96 60 85 33
 67 45 17 36  4 94 40  4 23 17 59 67 22 68 53 57 38  3 33 99
 70 38 97 46 64 90 18  5  1 73 49 31 40 75 35 35 26 82 57 18
 24 49 15 99 80 48 71  5  1 75 12  2 34 90 71 50 97 92 36 50
 23 83 66 74 14 91 81 45 18  8  4 56 82  5 58 52  8 66 63 23

W języku Python tablice są natywnie dynamiczne i tworzymy je standardowo (można również korzystać z różnych bibliotek, np. NumPy - ale tutaj nie będę ich celowo stosował, aby pokazać istotne operacje):

Python (dodatek)

# Macierze
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0051
#---------------------------

from random import randint

# Program główny
#---------------

# Generujemy rozmiar tablicy:
# n - liczba wierszy:    5...15
# m - liczba kolumn:    10...20

n = randint(5,15)
m = randint(10,20)

# Tworzymy dynamicznie
# listę list i wypełniamy
# ją liczbami pseudolosowymi
# już w trakcie tworzenia
a = [[randint(0,99) for _ in range(m)]
     for _ in range(n)]

# Wyświetlamy wyniki
print(f"Tablica dynamiczna {n} x {m}"
      "\n------------------\n")
for i in range(n):
    for j in range(m):
        print(f"{a[i][j]:3}",end="")
    print() # Koniec wiersza

# Jeśli macierzy już nie
# potrzebujemy, to możemy
# ją albo usunąć (del a),
# albo wyzerować (a = [])

print()
input("Naciśnij Enter")

Macierz może również zostać odwzorowana jako klasa języka C++ (jako klasa Pythona). W klasie można zdefiniować różne operacje na zawartej w niej macierzy. Plik definiujący klasę można używać jako plik nagłówkowy w programach przetwarzających macierze. Zaletą klasy jest to, iż prosto możemy zdefiniować w programie wiele różnych macierzy, które będą obsługiwane przez swoje funkcje składowe.

Poniższy program demonstruje przykładową prostą klasę macierzy liczb całkowitych. Klasa ta wspiera operacje przypisywania wartości elementom macierzy oraz odczytywania wartości elementów (dla prostoty klasa nie sprawdza błędów). Zwróć uwagę, iż zarezerwowano obszar dla tablicy jednowymiarowej. Tak też można.

C++

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

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

using namespace std;

// Definicja klasy
//----------------

#ifndef _matrix_class0052
  #define _matrix_class0052
  class matrix
  {
    private:
      // Elementy macierzy
      int * A;
    public:
      // Rozmiar macierzy
      int n,m;
      // Konstruktor
      matrix(int r, int c);
      // Destruktor
      ~matrix();
      void setv(int r, int c, int v);
      int  getv(int r, int c);
  };

  // Konstruktor tworzy macierz
  // o podanych wymiarach:
  // r - liczba wierszy
  // c - liczba kolumn
  //----------------------------
  matrix::matrix(int r, int c)
  {
    n = r;
    m = c;
    A = new int [n * m];
  }

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

  // Ustawia wartość elementu
  // r - numer wiersza
  // c - numer kolumny
  // v - wartość dla elementu
  //-------------------------
  void matrix::setv(int r, int c,
                    int v)
  {
    A[r * m + c] = v;
  }

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

#endif // _matrix_class0052

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

int main()
{
  // Inicjujemy generator
  // pseudolosowy
  srand(time(NULL));

  // Generujemy rozmiar tablicy:
  // n - liczba wierszy:  5...15
  // m - liczba kolumn:  10...20
  int n =  5 + rand() % 11;
  int m = 10 + rand() % 11;

  // Tworzymy macierz
  matrix A(n,m);

  // Macierz wypełniamy
  // liczbami pseudolosowymi
  // od -99 do 99
  int i,j;

  for(i = 0; i < n; i++)
    for(j = 0; j < m; j++)
      A.setv(i,j,-99+rand()% 199);

  // Wyświetlamy macierz

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << "Klasa macierzy o rozmiarze "
       << n << " x " << m << endl
       << "--------------------------"
       << endl << endl;
  for(i = 0; i < n; i++)
  {
    for(j = 0; j < m; j++)
      cout << setw(4) << A.getv(i,j);
    cout << endl;
  }

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

Wynik

Klasa macierzy o rozmiarze 10x15
--------------------------------

55 -98 -58 16 10 -13 87 26 -51 -20   0 20 -76 68 -91
   0 20 -76 68 -91 -85 -6 96 75 96 32 -38 -18 -79 -92
32 -38 -18 -79 -92 73 99 62 -63 37 73 -65 -19 30 17
73 -65 -19 30 17 -29 75 55 57 99 85 35 -36 73 -43
85 35 -36 73 -43 -35 -57 -45 -35 83 -89   4 65   6 10
-89   4 65   6 10 -27 67 64 -49 -39 -95 -57 -75 -54 60
-95 -57 -75 -54 60 -44 86 22 -16 14 61 -80 -57 18 -40
61 -80 -57 18 -40 -46 -69 25 -89   7 -8 -3 33 -80 27
-8 -3 33 -80 27 78 -78 48 85 -90 54 84 75 -94 59
54 84 75 -94 59 48 -60 -2 43 -22 78 39 -94 -20 52

Python (dodatek)

# Macierze
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0052
#---------------------------

from random import randint

# Definicja klasy
#----------------
class Matrix():

    # Konstruktor tworzy macierz
    # o podanych wymiarach:
    # r - liczba wierszy
    # c - liczba kolumn
    #---------------------------
    def __init__(self, r, c):
        self.n = r
        self.m = c
        self.a = [0] * (r * c)

    # Ustawia wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    # v - wartość dla elementu
    #-------------------------
    def setv(self, r, c, v):
        self.a[r * self.m + c] = v

    # Zwraca wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    #-------------------------
    def getv(self, r, c):
        return self.a[r * self.m + c]

# Program główny
#---------------

# Tworzymy pustą macierz
# n - liczba wierszy: 5...15
# m - liczba kolumn: 10...20
t = Matrix(randint(5,15),
           randint(10,20))

# Macierz wypełniamy
# liczbami pseudolosowymi
# od -99 do 99
for i in range(t.n):
    for j in range(t.m):
        t.setv(i,j,randint(-99,99))

# Wyświetlamy macierz
print(
f"Klasa macierzy o rozmiarze "
f"{t.n} x {t.m}"
f"\n--------------------------\n")
for i in range(t.n):
    for j in range(t.m):
        print(f"{t.getv(i,j):4}",
              end="")
    print() # Nowy wiersz po każdym
            # wierszu macierzy
print()
input("Naciśnij Enter...")

Lepszym pomysłem jest wykorzystanie klasy szablonowej. Klasa szablonowa nie określa bezpośrednio typu elementów macierzy - robi to program użytkownika w momencie tworzenia zmiennej na podstawie szablonu klasy. Dzięki temu możemy w prosty sposób otrzymać macierz o dowolnym typie elementów.

Poniższy przykład programu definiuje klasę szablonową macierzy, następnie na jej podstawie tworzy macierz liczb typu double, wypełnia ją pseudolosowymi wartościami i wyświetla jej zawartość. Wszystko jest maksymalnie uproszczone.

C++

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

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

using namespace std;

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

template <class T> class matrix
{
  private:
    T * A;    // Elementy
  public:
    int n,m;  // Rozmiar macierzy
    // Konstruktor
    matrix(int r, int c);
    // Destruktor
    ~matrix();
    // Zapis
    void setv(int r, int c, T v);
    // Odczyt
    T getv(int r, int c);
};

// Konstruktor tworzy macierz
// o podanych wymiarach:
// r - liczba wierszy
// c - liczba kolumn
//---------------------------
template <class T> matrix<T>
         ::matrix(int r, int c)
{
  n = r;
  m = c;
  A = new T [n * m];
}

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

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

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

#endif // _matrix_class0053

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

int main()
{
  // Inicjujemy generator
  // pseudolosowy
  srand(time(NULL));

  // Generujemy rozmiar tablicy:
  // n - liczba wierszy: 5...15
  // m - liczba kolumn:  5...15

  int n = 5 + rand()% 11;
  int m = 5 + rand()% 11;

  // Tworzymy macierz
  matrix <double> A(n,m);

  // Macierz wypełniamy
  // liczbami pseudolosowymi
  // od 0 do 9.99
  int i,j;
  for(i = 0; i < n; i++)
    for(j = 0; j < m; j++)
      A.setv(i,j,(rand()% 1000)/100.0);

  // Wyświetlamy macierz

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout << setprecision(2)
       << fixed;
  cout << "Klasa szablonowa macierzy "
       << n << " x " << m << endl
       << "-------------------------"
       << endl << endl;
  for(i = 0; i < n; i++)
  {
    for(j = 0; j < m; j++)
      cout << setw(5) << A.getv(i,j);
    cout << endl; // Koniec wiersza
  }

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

Wynik

Klasa szablonowa macierzy 10 x 13
-------------------------

 0.79 5.49 6.75 2.76 9.51 6.30 2.21 2.45 9.46 1.14 8.21 5.40 8.26
 9.55 5.87 1.80 6.12 1.73 2.88 1.49 8.51 3.89 4.36 4.69 6.61 8.46
 0.30 1.30 4.18 4.70 3.72 9.74 4.18 6.56 9.71 4.67 0.62 1.15 0.25
 3.45 2.43 5.16 5.06 9.91 8.98 6.63 5.60 3.34 0.59 5.72 7.90 7.16
 4.83 6.87 1.34 5.03 1.47 2.40 3.61 0.00 6.84 4.61 2.96 0.35 0.24
 7.81 3.92 1.64 4.98 6.62 4.75 6.36 9.60 5.92 8.05 4.44 8.07 6.36
 2.68 3.05 2.89 8.40 8.76 0.41 0.03 6.84 1.22 3.57 4.18 5.46 3.11
 9.59 5.51 8.25 3.43 6.14 7.19 4.10 5.78 7.83 5.76 5.03 9.07 7.66
 5.77 2.57 8.72 7.10 6.98 0.09 4.25 6.13 3.96 3.45 9.40 9.79 7.30
 9.15 4.47 8.45 8.40 2.42 4.00 4.05 7.07 6.89 7.86 0.84 4.09 5.61

Poniższy program w Pythonie jest taki sam jak poprzedni - zmieniamy tylko rodzaj elementów przechowywanych w macierzy:

Python (dodatek)

# Macierze
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0053
#---------------------------

from random import uniform, randint

# Definicja klasy
#----------------
class Matrix():

    # Konstruktor tworzy macierz
    #  o podanych wymiarach:
    # r - liczba wierszy
    # c - liczba kolumn
    #---------------------------
    def __init__(self, r, c):
        self.n = r
        self.m = c
        self.a = [0] * (self.n * self.m)

    # Ustawia wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    # v - wartość dla elementu
    #-------------------------
    def setv(self, r, c, v):
        self.a[r*self.m+c] = v

    # Zwraca wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    #-------------------------
    def getv(self, r, c):
        return self.a[r*self.m+c]

# Program główny
#---------------

# Tworzymy pustą macierz
# n - liczba wierszy: 5...15
# m - liczba kolumn:  5...15
t = Matrix(randint(5,15),
           randint(5,15))

# Macierz wypełniamy
# liczbami pseudolosowymi
# od 0 do 9.99
for i in range(t.n):
    for j in range(t.m):
        t.setv(i,j,uniform(0,9.99))

# Wyświetlamy macierz
print(
f"Klasa macierzy o rozmiarze "
f"{t.n} x {t.m}"
f"\n--------------------------\n")
for i in range(t.n):
    for j in range(t.m):
        print(f"{t.getv(i,j):5.2f}",
              end="")
    print() # Nowy wiersz po każdym
            # wierszu macierzy

# Jeśli jest konieczne,
# można usunąć macierz:
# del t

print()
input("Naciśnij Enter...")

W dalszej części artykułu będziemy wykorzystywali klasę szablonową z odpowiednimi modyfikacjami, ponieważ jest najbardziej ogólna.

W języku Python zmienne mają typy dynamiczne, dlatego zamiast klasy szablonowej stosujemy zwykłą klasę macierzy, gdzie typ jej elementów jest określany w trakcie działania programu.

do podrozdziału do strony

Podamy tutaj proste sposoby wprowadzania danych do programu przetwarzającego macierze. Dane można umieszczać bezpośrednio w programie, w pliku lub wprowadzać je przez strumień wejścia.

Dane umieszczone w programie nie są specjalnie wygodnym sposobem definiowania zawartości macierzy, ponieważ zmiana danych wymaga modyfikacji programu. Niemniej jednak ten sposób może być czasem przydatny.

Poniższy program tworzy macierz jednostkową (macierz jednostkowa I ma wszystkie elementy równe 0 za wyjątkiem głównej przekątnej, na której elementy mają wartość 1) i wyświetla jej zawartość:

C++

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

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

using namespace std;

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

#ifndef _matrix_class0054
  #define _matrix_class0054

template <class T> class matrix
{
  private:
    // Elementy
    T * A;
  public:
    // Rozmiar macierzy
    int n,m,s;
    // Konstruktor
    matrix(int r, int c);
    // Destruktor
    ~matrix();
    // Macierz jednostkowa
    void makeIdent(void);
    // Odczyt
    T getv(int r, int c);
};

// Konstruktor tworzy macierz
// o podanych wymiarach:
// r - liczba wierszy
// c - liczba kolumn
//---------------------------
template <class T> matrix<T>
         ::matrix(int r, int c)
{
  // Zapamiętujemy wymiary
  // macierzy
  n = r; // Wiersze
  m = c; // Kolumny
  s = n * m; // Wielkość
  // Macierz dynamiczna
  A = new T [s];
}

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

// Tworzy macierz jednostkową
//-------------------------
template <class T>
         void matrix<T>
         ::makeIdent()
{
  int i;
  // Macierz wypełniamy zerami
  for(i = 0; i < s; i++)
    A[i] = (T)0;
  // Na głównej przekątnej
  // umieszczamy jedynki
  for(i = 0; i < n; i++)
    A[i * m + i] = (T)1;
}

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

#endif // _matrix_class0054

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

int main()
{
  // Inicjujemy generator
  // pseudolosowy
  srand(time(NULL));

  // Generujemy rozmiar
  // macierzy:
  // n - liczba wierszy
  //     i kolumn: 10...20
  int n,i,j;

  n = 10 + rand()% 11;

  // Tworzymy pustą
  // macierz kwadratową
  matrix<int> A(n,n);

  // Tworzymy macierz
  // jednostkową
  A.makeIdent();

  // Wyświetlamy macierz
  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout
  << "Macierz jednostkowa o rozmiarze "
  << n << " x " << n << endl
  << "-------------------------------"
  << endl << endl;
  for(i = 0; i < n; i++)
  {
    for(j = 0; j < n; j++)
      cout << setw(2) << A.getv(i,j);
    cout << endl; // Koniec wiersza
  }

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

Wynik

Macierz jednostkowa o rozmiarze 13 x 13
-------------------------------

 1 0 0 0 0 0 0 0 0 0 0 0 0
 0 1 0 0 0 0 0 0 0 0 0 0 0
 0 0 1 0 0 0 0 0 0 0 0 0 0
 0 0 0 1 0 0 0 0 0 0 0 0 0
 0 0 0 0 1 0 0 0 0 0 0 0 0
 0 0 0 0 0 1 0 0 0 0 0 0 0
 0 0 0 0 0 0 1 0 0 0 0 0 0
 0 0 0 0 0 0 0 1 0 0 0 0 0
 0 0 0 0 0 0 0 0 1 0 0 0 0
 0 0 0 0 0 0 0 0 0 1 0 0 0
 0 0 0 0 0 0 0 0 0 0 1 0 0
 0 0 0 0 0 0 0 0 0 0 0 1 0
 0 0 0 0 0 0 0 0 0 0 0 0 1

Python (dodatek)

# Macierze
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0054
#---------------------------

from random import randint

# Definicja klasy
#----------------
class Matrix():

    # Konstruktor tworzy macierz
    # o podanych wymiarach:
    # r - liczba wierszy
    # c - liczba kolumn
    #---------------------------
    def __init__(self, r, c):
        self.n = r
        self.m = c
        self.s = self.n * self.m
        self.a = [0] * self.s

    # Ustawia wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    # v - wartość dla elementu
    #-------------------------
    def setv(self, r, c, v):
        self.a[r*self.m+c] = v

    # Zwraca wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    #-------------------------
    def getv(self, r, c):
        return self.a[r*self.m+c]

    # Tworzy macierz jednostkową
    #-------------------------
    def make_ident(self):
        # Macierz wypełniamy
        # zerami
        for i in range(self.s):
            self.a[i] = 0

        # Na głównej przekątnej
        # umieszczamy jedynki
        for i in range(self.n):
            self.a[i*self.m+i] = 1

# Program główny
#---------------

# Generujemy rozmiar
# macierzy:
# n - liczba wierszy
#     i kolumn: 10...20
n = randint(10, 20)

# Tworzymy macierz
# kwadratową
a = Matrix(n, n)

# Tworzymy macierz
# jednostkową
a.make_ident()

# Wyświetlamy macierz
print("Macierz jednostkowa "
      "o rozmiarze ",
      n, " x ", n)
print("--------------------"
      "-----------")
print()
for i in range(n):
    for j in range(n):
        print(f"{a.getv(i,j):2d}",
              end=" ")
    print()  # Koniec wiersza

print()
input("Naciśnij Enter...")

Następne dwa programy odczytują dane dla macierzy ze strumienia. Pierwszy odczytuje dane z pliku dane0055.txt, który należy umieścić w katalogu projektowym, jeśli pracujesz w edytorze Code Blocks, lub w katalogu z programem, jeśli uruchamiasz program z poziomu konsoli lub menedżera plików. Inaczej program EXE nie znajdzie pliku z danymi.

Dane są skonstruowane następująco:

W pierwszym wierszu dwie liczby określają rozmiar macierzy: n – liczba wierszy i m – liczba kolumn, są to liczby całkowite
W kolejnych n wierszach musi wystąpić po m danych w każdym. Pomiędzy elementami muszą być znaki spacji lub odstępu. W liczbach należy stosować kropki zamiast przecinków (notacja anglosaska).

Przykładowe dane:

5 6
1 6 8 7 5 6
8 8 9 2 1 0
3 1 4 7 2 1
2 2 0 7 9 1
0 0 0 2 2 2

Przekopiuj przykładowy plik dane0055.txt do odpowiedniego katalogu lub utwórz swój własny (np. w notatniku).

Poniższy program tworzy macierz na podstawie danych z pliku. Zakładamy, że dane są liczbami całkowitymi bez znaku (typ macierzy musi się zgadzać z typem danych w pliku). Następnie program wyświetla zawartość wczytanej macierzy.

C++

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

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

using namespace std;

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

template <class T>
         class matrix
{
  private:
    // Elementy
    T * A;
  public:
    // Rozmiar macierzy
    int n,m,s;
    // Konstruktor
    matrix();
    // Destruktor
    ~matrix();
    // Odczyt
    T getv(int r, int c);
};

// Konstruktor tworzy
// macierz z pliku
// dane0053.txt
//-------------------
template <class T>
         matrix<T>::matrix()
{
  // Strumień wejścia
  // z pliku
  ifstream fin;

  // Otwieramy strumień do
  // odczytu
  fin.open("dane0055.txt",
           ifstream::in);

  // Odczytujemy ze strumienia
  // wymiary macierzy
  fin >> n >> m;

  // Obliczamy wielkość
  // macierzy
  s = n * m;

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

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

  // Zamykamy strumień
  fin.close();
}

// 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 * m + c];
}

#endif // _matrix_class0055

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

int main()
{
  // Tworzymy macierz
  // liczb całkowitych
  matrix<int> A;

  // Wyświetlamy macierz
  int i,j;

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

  cout
  << "Macierz z pliku o rozmiarze "
  << A.n << " x " << A.m << endl
  << "---------------------------"
  << endl << endl;

  for(i = 0; i < A.n; i++)
  {
    for(j = 0; j < A.m; j++)
      cout << setw(4)
           << A.getv(i,j);
    cout << endl; // Koniec wiersza
  }

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

Wynik

Macierz z pliku o rozmiarze 5 x 6
---------------------------

   1   6   8   7   5   6
   8   8   9   2   1   0
   3   1   4   7   2   1
   2   2   0   7   9   1
   0   0   0   2   2   2

Python (dodatek)

 # Macierze
 # (C)2019 mgr Jerzy Wałaszek
 # Metody numeryczne 0055
 #---------------------------

# Definicja klasy,
class Matrix():

    # Konstruktor tworzy
    # macierz z pliku
    # dane0055.txt
    #-------------------
    def __init__(self):
        with open("dane0055.txt","r") as f:
            # Wczytuje wszystkie
            # wyrazy oddzielone
            # jakimkolwiek białym
            # znakiem i rozdziela
            # je na listę
            aa = f.read().split()
            
            # Dwa pierwsze
            # elementy to wymiary
            self.n = int(aa[0]) # wiersze
            self.m = int(aa[1]) # kolumny
            
            # Liczba elementów
            self.s = self.n * self.m
            
            # Konwertujemy resztę
            # na liczby z pominięciem
            # pierwszych dwóch elementów
            self.a = [int(x)
                      for x in aa[2:]]

    # Zwraca wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    #-------------------------
    def getv(self, r, c):
        return self.a[r*self.m+c]

# Program główny
#---------------

# Tworzymy macierz
a = Matrix()

# Wyświetlamy macierz
print("Macierz z pliku o rozmiarze ",
      a.n," x ",a.m)
print("---------------------------\n")

for i in range(a.n):
    for j in range(a.m):
        print(f"{a.getv(i,j):4}",
              end="")
    print() # Koniec wiersza

print()
input("Naciśnij Enter...")

Kolejny program jest właściwie identyczny z poprzednim. Różnica polega na tym, iż dane dla macierzy odczytywane są ze standardowego strumienia. Poniższe dane skopiuj do schowka, uruchom program i wklej je do okna konsoli (Windows: Ctrl+V, Linux Ctrl+Shift+V) :

Dane wejściowe: 10 15 126 22 36 4 54 6 7 88 96 0 13 25 3 47 52 75 0 95 62 46 73 21 5 32 17 0 27 8 29 34 82 85 6 21 343 16 28 8 5 44 83 29 911 93 23 99 655 96 222 32 24 1 96 68 8 21 3 4 53 18 81 93 598 6 32 25 29 21 63 11 56 71 92 12 6 0 734 8 27 7 37 5 53 1 89 9 34 37 22 0 929 7 26 5 533 5 2 29 22 15 92 83 47 28 0 4 444 7 6 8 9 26 3 69 86 87 888 92 43 15 51 34 66 87 51 62 88 92 83 99 11 13 6 55 6 19 2 3 4 5 6 74 8 9 10 11 12 13 14 15

C++

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

#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:
    // Elementy
    T * A;
  public:
    // Rozmiar macierzy
    int n,m,s;
    // Konstruktor
    matrix();
    // Destruktor
    ~matrix();
    // Wartość elementu
    T getv(int r, int c);
};

// Konstruktor tworzy
// macierz ze strumienia cin
//--------------------------
template <class T>
         matrix<T>::matrix()
{
  // Odczytujemy ze strumienia
  // wymiary macierzy
  cin >> n >> m;

  // Liczymy wielkość macierzy
  s = n * m;

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

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

// 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 * m + c];
}

#endif // _matrix_class

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

int main()
{
  // Pobieramy macierz
  // ze strumienia cin
  int i,j;

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

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

  // Tworzymy macierz
  // z wczytaniem jej
  // ze strumienia
  matrix<int> A;

  cout
  << "\nMacierz o rozmiarze "
  << A.n << " x " << A.m
  << "\n--------------------\n\n";

  for(i = 0; i < A.n; i++)
  {
     for(j = 0; j < A.m; j++)
       cout << setw(4)
            << A.getv(i,j);
     cout << endl; // Koniec wiersza
  }

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

Wynik

Wpisz dane dla macierzy:

10 15
126 22 36 4 54 6 7 88 96 0 13 25 3 47 52
75 0 95 62 46 73 21 5 32 17 0 27 8 29 34
82 85 6 21 343 16 28 8 5 44 83 29 911 93 23
99 655 96 222 32 24 1 96 68 8 21 3 4 53 18
81 93 598 6 32 25 29 21 63 11 56 71 92 12 6
0 734 8 27 7 37 5 53 1 89 9 34 37 22 0
929 7 26 5 533 5 2 29 22 15 92 83 47 28 0
4 444 7 6 8 9 26 3 69 86 87 888 92 43 15
51 34 66 87 51 62 88 92 83 99 11 13 6 55 6
19 2 3 4 5 6 74 8 9 10 11 12 13 14 15

Macierz o rozmiarze 10 x 15
--------------------

 126  22  36   4  54   6   7  88  96   0  13  25   3  47  52
  75   0  95  62  46  73  21   5  32  17   0  27   8  29  34
  82  85   6  21 343  16  28   8   5  44  83  29 911  93  23
  99 655  96 222  32  24   1  96  68   8  21   3   4  53  18
  81  93 598   6  32  25  29  21  63  11  56  71  92  12   6
   0 734   8  27   7  37   5  53   1  89   9  34  37  22   0
 929   7  26   5 533   5   2  29  22  15  92  83  47  28   0
   4 444   7   6   8   9  26   3  69  86  87 888  92  43  15
  51  34  66  87  51  62  88  92  83  99  11  13   6  55   6
  19   2   3   4   5   6  74   8   9  10  11  12  13  14  15

Python (dodatek)

 # Macierze
 # (C)2019 mgr Jerzy Wałaszek
 # Metody numeryczne 0055
 #---------------------------

# Definicja klasy
#----------------
class Matrix():

    # Konstruktor tworzy
    # macierz z danych
    # z wejścia
    #-------------------
    def __init__(self):
        # odczytujemy 2 liczby
        # z pierwszego wiersza
        # - to wymiary macierzy
        aa = input().split()

        # Wymiary zapamiętujemy
        # w atrybutach obiektu
        self.n = int(aa[0]) # wiersze
        self.m = int(aa[1]) # kolumny
            
        # Obliczamy liczbę elementów
        self.s = self.n * self.m
            
        # Odczytujemy n wierszy
        # i łączymy je w jedną listę
        aa = []
        for _ in range(self.n):
            aa += input().split()

        # Konwertujemy listę
        # na liczby
        self.a = [int(x) for x in aa]

    # Zwraca wartość elementu
    # r - numer wiersza
    # c - numer kolumny
    #-------------------------
    def getv(self, r, c):
        return self.a[r*self.m+c]

# Program główny
#---------------

print("Wpisz dane dla macierzy:\n")

# Tworzymy macierz
a = Matrix()

# Wyświetlamy macierz
print("\nMacierz o rozmiarze ",
      a.n," x ",a.m)
print("-------------------\n")

for i in range(a.n):
    for j in range(a.m):
        print(f"{a.getv(i,j):4}",
              end="")
    print() # Koniec wiersza

print()
input("Naciśnij Enter...")

W dalszej części artykułu będziemy stosować tę ostatnią metodę do wprowadzania danych macierzowych w przykładowych programach.

do podrozdziału do strony

Na macierzach można wykonywać różne operacje arytmetyczne, które krótko opisujemy poniżej:

Transpozycja

Jeśli w macierzy zamienimy wiersze z kolumnami to otrzymamy macierz transponowaną. Operację transponowania macierzy (ang. matrix transposition) zapisujemy dużą literą T w indeksie górnym:

Poniższy program wczytuje macierz ze standardowego wejścia i dokonuje jej transpozycji. Dane dla macierzy są pobierane ze strumienia wejściowego.

Przykładowe dane (przekopiuj je do schowka i wklej w programie) :

Macierz:

Dane wejściowe: 4 6 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

C++

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

#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:
            int s;                // Rozmiar macierzy
            T * A;                // Elementy
        public:
            int n,m;              // Liczba wierszy i kolumn
            matrix();             // Konstruktor
            ~matrix();            // Destruktor
            T  getv(int r, int c);
            void transpose();     // Dokonuje transpozycji macierzy
    };

    // Konstruktor - tworzy macierz ze strumienia cin
    //-----------------------------------------------
    template <class T> matrix<T>::matrix()
    {
        cin >> n >> m; // Rozmiar macierzy
        s = n * m;
        A = new T [s]; // Rezerwujemy pamięć na macierz n x m

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

    // 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 * m + c];
    }

    // Transponuje macierz
    //--------------------
    template <class T> void matrix<T>::transpose()
    {
        T * B = new T[s];  // Tymczasowa macierz o tej samej liczbie elementów
        int i,j;
        for(i = 0; i < n; i++)
            for(j = 0; j < m; j++)B[j * n + i] = A[i * m + j];
        delete [] A;       // Usuwamy starą macierz
        A = B;             // Podmieniamy ją macierzą transponowaną
        swap(n,m);         // Zamieniamy wiersze z kolumnami
    }
#endif // _matrix_class

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

int main()
{

    // Wczytujemy dane dla macierzy

    SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

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

    matrix<int> A;

    cout << endl
         << "Macierz przed transponowaniem ma wymiary " << A.n << " x " << A.m << endl
         << "----------------------------------------------" << endl << endl;
    for(int i = 0; i < A.n; i++)
    {
        for(int j = 0; j < A.m; j++)cout << setw(6)<< A.getv(i,j);
        cout << endl;
    }

    // Transponujemy macierz

    A.transpose();

    cout << endl << endl
         << "Macierz po transponowaniu ma wymiary " << A.n << " x " << A.m << endl
         << "------------------------------------------" << endl << endl;
    for(int i = 0; i < A.n; i++)
    {
        for(int j = 0; j < A.m; j++)cout << setw(6)<< A.getv(i,j);
        cout << endl;
    }

    cout << endl << endl;

    return 0;
}

Wynik

Wpisz dane dla macierzy:

4 6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Macierz przed transponowaniem ma wymiary 4 x 6
----------------------------------------------

     1     2     3     4     5     6
     7     8     9    10    11    12
    13    14    15    16    17    18
    19    20    21    22    23    24

Macierz po transponowaniu ma wymiary 6 x 4
------------------------------------------

     1     7    13    19
     2     8    14    20
     3     9    15    21
     4    10    16    22
     5    11    17    23
     6    12    18    24

Mnożenie przez skalar

Macierze można mnożyć przez liczbę. Wynikiem takiego mnożenia jest macierz, której wszystkie elementy zostały pomnożone przez daną liczbę:

Dodawanie macierzy

Dodawać można macierze o tych samych wymiarach. Wynikiem dodawania jest macierz, której elementy są sumami odpowiadających sobie elementów obu macierzy:

Mnożenie macierzy

Mnożenie w przypadku macierzy jest trochę bardziej skomplikowane. Aby można było pomnożyć dwie macierze, muszą one spełniać pewien warunek, mianowicie, jeśli pierwsza macierz A ma m kolumn, to druga macierz B musi posiadać m wierszy:

A_{n × m} × B_{m × p} = C_{n × p}

Macierz wynikowa C posiada tyle wierszy, ile miała macierz A i tyle kolumn, ile miała macierz B.

Zasadę mnożenia najlepiej jest zrozumieć na prostym przykładzie. Mamy dwie macierze:

Macierz A ustawiamy po lewej stronie macierzy C, a macierz B ustawiamy ponad macierzą C:

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		?	?	?	?	?
A =	8	10	12	14	C =	?	?	?	?	?
	16	18	20	22		?	?	?	?	?

Kolejne elementy c_ij macierzy C obliczamy jako sumę iloczynów kolejnych elementów z wiersza i-tego macierzy A przez kolejne elementy z kolumny j-tej macierzy B. Na przykład:

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		292	?	?	?	?
A =	8	10	12	14	C =	?	?	?	?	?
	16	18	20	22		?	?	?	?	?

W ten sam sposób obliczamy pozostałe elementy macierzy C.

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		292	316	340	364	388
A =	8	10	12	14	C =	804	892	980	1068	1156
	16	18	20	22		1316	1468	1620	1772	1924

Poniższy program mnoży dwie macierze i wyświetla wynik mnożenia. Dane wejściowe są odczytywane ze strumienia wejściowego. Dane macierzy poprzedzone są dwoma liczbami, które oznaczają liczbę wierszy i kolumn. Za tymi liczbami należy umieścić odpowiednią liczbę elementów dla macierzy. Elementy są liczbami całkowitymi. Program nie sprawdza poprawności danych.

Przykładowe dane (przekopiuj je do schowka i wklej w programie) :

Macierze:

Dane wejściowe: 3 4 0 2 4 6 8 10 12 14 16 18 20 22 4 5 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39

C++

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

#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:
            int s;                // Rozmiar macierzy
            T * A;                // Elementy macierzy A
        public:
            int n,m;              // Liczba wierszy i kolumn
            matrix();             // Konstruktor
            matrix(int r, int c); // Konstruktor
            ~matrix();            // Destruktor
            T  getv(int r, int c);
            void multiply(matrix<T> & a, matrix<T> & b);
    };

    // Konstruktor - tworzy macierz ze strumienia cin
    //-----------------------------------------------
    template <class T> matrix<T>::matrix()
    {
        cin >> n >> m;   // Rozmiar macierzy
        s = n * m;
        A = new T [s]; // Rezerwujemy pamięć na macierz n x m

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

    // Konstruktor - tworzy pustą macierz na podstawie wymiarów
    //---------------------------------------------------------
    template <class T> matrix<T>::matrix(int r, int c)
    {
        n = r;
        m = c;
        s = n * m;
        A = new T [s]; // Rezerwujemy pamięć na macierz n x m
    }

    // 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 * m + c];
    }

    // Mnoży macierze
    //--------------------
    template <class T> void matrix<T>::multiply(matrix<T> & a, matrix<T> & b)
    {
         T sum;
         int i,j,k;

         for(i = 0; i < n; i++)
             for (j= 0; j < m; j++)
             {
                 sum = 0;
                 for(k = 0;k < a.m; k++)sum += a.getv(i,k)* b.getv(k,j);
                 A[i * m + j] = sum;
             }
    }
#endif // _matrix_class

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

int main()
{
    // Wczytujemy dane dla macierzy

    SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

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

    matrix<int> A;
    matrix<int> B;

    // Ustawiamy macierz wyniku

    matrix<int> C(A.n,B.m);

    cout << endl
         << "Mnożenie macierzy" << endl
         << "-----------------" << endl << endl;
    cout << "Macierz A" << A.n << "x" << A.m << endl;

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

    cout << "Macierz B" << B.n << "x" << B.m << endl;

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

    // Mnożymy macierz A przez macierz B i wynik wpisujemy do macierzy C

    C.multiply(A,B);

    cout << "Wynik mnożenia w macierzy C" << C.n << "x" << C.m << endl;

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

    cout << endl;

    return 0;
}

Wynik

Wpisz dane dla macierzy:

3 4
0 2 4 6 8 10 12 14 16 18 20 22
4 5
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39

Mnożenie macierzy
-----------------

Macierz A3x4
     0     2     4     6
     8    10    12    14
    16    18    20    22

Macierz B4x5
     1     3     5     7     9
    11    13    15    17    19
    21    23    25    27    29
    31    33    35    37    39

Wynik mnożenia w macierzy C3x5
   292   316   340   364   388
   804   892   980 1068 1156
1316 1468 1620 1772 1924

do podrozdziału do strony

Równania

Macierze

Definicje

Tablice dynamiczne

Wprowadzanie danych

Operacje na macierzach

Transpozycja

Mnożenie przez skalar

Dodawanie macierzy

Mnożenie macierzy

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		?	?	?	?	?
A =	8	10	12	14	C =	?	?	?	?	?
	16	18	20	22		?	?	?	?	?

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		?	?	?	?	?
A =	8	10	12	14	C =	?	?	?	?	?
	16	18	20	22		?	?	?	?	?

						1	3	5	7	9
					B =	11	13	15	17	19
					B =	21	23	25	27	29
						31	33	35	37	39

	0	2	4	6		?	?	?	?	?
A =	8	10	12	14	C =	?	?	?	?	?
	16	18	20	22		?	?	?	?	?