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
t = [[randrange(100)
     for _ in range(20)]
     for _ in range(10)]

# Wyświetlamy wyniki
for i in range(10):
    for j in range(20):
        print(f"{t[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
t = [[randint(0,99)
     for _ in range(m)]
     for _ in range(n)]

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

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
         for _ in range(c)]
         for _ in range(r)]

# 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.a[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.a[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
         for _ in range(self.m)]
         for _ in range(self.n)]

# 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.a[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.a[i][j]:5.2f}",
              end="")
    print() # Nowy wiersz po każdym
            # wierszu macierzy

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.a = [[0
         for _ in range(self.m)]
         for _ in range(self.n)]

    # Tworzy w macierzy
    # macierz jednostkową
    #--------------------
    def make_ident(self):
        # Macierz wypełniamy
        # zerami lub 1 na
        # głównej przekątnej
        for i in range(self.n):
            for j in range(self.m):
                if i == j:
                    self.a[i][j] = 1
                else:
                    self.a[i][j] = 0

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

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

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

# Tworzymy macierz
# jednostkową
t.make_ident()

# Wyświetlamy macierz
print("Macierz jednostkowa "
      "o rozmiarze ",
      n, " x ", n)
print("--------------------"
      "-----------")
print()
for i in range(t.n):
    for j in range(t.m):
        print(f"{t.a[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:
            # Wczytujemy pierwszy  wiersz
            # zawierający wymiary macierzy
            x = f.readline().split()
            
            # Odczytujemy wymiary macierzy
            self.n = int(x[0])
            self.m = int(x[1])
            
            # Odczytujemy pozostałe
            # wiersze i tworzymy z nich
            # macierz: listę list
            self.a = [[int(el)
             for el in line.split()]
             for line in f]

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

# Tworzymy macierz
t = Matrix()

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

for i in range(t.n):
    for j in range(t.m):
        print(f"{t.a[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
        x = input().split()

        # Wymiary zapamiętujemy
        # w atrybutach obiektu
        self.n = int(x[0]) # wiersze
        self.m = int(x[1]) # kolumny
            
        # Odczytujemy n wierszy
        # i tworzymy z nich macierz
        # czyli listę list.
        self.a = [[int(el)
         for el in input().split()]
         for _ in range(self.n)]

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

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

# Tworzymy macierz
t = Matrix()

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

for i in range(t.n):
    for j in range(t.m):
        print(f"{t.a[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:
    // Elementy
    T * A;
  public:
    // Rozmiar macierzy
    int s;
    // Liczba wierszy i kolumn
    int n,m;
    // Konstruktor
    matrix();
    // Destruktor
    ~matrix();
    T getv(int r, int c);
    // Dokonuje transpozycji
    // macierzy
    void transpose();
};

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

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

  // Rezerwujemy pamięć
  // na macierz n x m
  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 * m + c];
}

// Transponuje macierz
//--------------------
template <class T>
         void matrix<T>
         ::transpose()
{
  // Tymczasowa macierz
  // o tej samej liczbie
  // elementów
  T * B = new T[s];
  int i,j;

  for(i = 0; i < n; i++)
    for(j = 0; j < m; j++)
      B[j * n + i] = A[i * m + j];

  // Usuwamy starą macierz
  delete [] A;

  // Podmieniamy ją
  // macierzą transponowaną
  A = B;

  // Zamieniamy wiersze
  // z kolumnami
  swap(n,m);
}

#endif // _matrix_class

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

  // Wczytujemy dane
  // dla macierzy

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

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

  // Tworzymy macierz
  matrix<int> A;

  cout
  << "\nMacierz przed transponowaniem "
     "ma wymiary "
  << A.n << " x " << A.m
  << "\n------------------------------"
     "----------\n\n";

  // Wyświetlamy macierz

  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 << "\n\nMacierz po "
          "transponowaniu ma wymiary "
       << A.n << " x " << A.m
       << "\n-----------"
          "-------------------------\n\n";
  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;
  system("pause");
  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

Python (dodatek)

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

# Definicja klasy
#----------------
class Matrix:

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

        # Wymiary zapamiętujemy
        # w atrybutach obiektu
        self.n = int(x[0]) # wiersze
        self.m = int(x[1]) # kolumny
            
        # Odczytujemy n wierszy
        # i tworzymy z nich macierz
        self.a = [[int(el)
          for el in input().split()]
          for _ in range(self.n)]

    # Transponuje macierz
    #--------------------
    def transpose(self):
        # Tymczasowa macierz
        # o m wierszach
        # i n kolumnach
        b = [[0
         for i in range(self.n)]
         for j in range(self.m)]

        # Kopiujemy a[] do b[]
        # z przemieszczeniem
        # elementów
        for j in range(self.m):
            for i in range(self.n):
                b[j][i] = self.a[i][j]

        # Podmieniamy macierze
        self.a = b

        # Zamieniamy wiersze
        # z kolumnami
        self.n,self.m = self.m,self.n   

#endif # _matrix_class

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

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

# Tworzymy macierz
t = Matrix()

print("\nMacierz przed transponowaniem "
      "ma wymiary ",t.n," x ",t.m,
      "\n------------------------------"
      "----------\n")

# Wyświetlamy macierz
for i in range(t.n):
    for j in range(t.m):
        print(f"{t.a[i][j]:6}",
              end="")
    print()

# Transponujemy macierz
t.transpose()

print("\nMacierz po transponowaniu "
      "ma wymiary ",t.n," x ",t.m,
      "\n--------------------------"
      "----------\n")

for i in range(t.n):
    for j in range(t.m):
        print(f"{t.a[i][j]:6}",
              end="")
    print()

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

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 muszą być wprowadzane wg opisanych wyżej zasad (najpierw wymiary, później wiersze). 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:
    // Elementy macierzy A
    T * A;
  public:
    // Rozmiar macierzy
    int s;
    // Liczba wierszy i kolumn
    int n,m;
    // Konstruktor 1
    matrix();
    // Konstruktor 2
    matrix(int r, int c);
    // Destruktor
    ~matrix();
    T getv(int r, int c);
    // Wykonuje mnożenie
    void mul(matrix<T> & a,
             matrix<T> & b);
    // Wypisuje macierz
    void prnt();
};

// Konstruktor 1 - tworzy
// macierz ze strumienia
// cin
//-----------------------
template <class T>
         matrix<T>::matrix()
{
  // Rozmiar macierzy
  cin >> n >> m;
  s = n * m;

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

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

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

// 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>::mul(
         matrix<T> & a,
         matrix<T> & b)
{
  T sm;
  int i,j,k;

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

// Wypisuje zawartość
// macierzy
//-------------------
template <class T>
    void matrix<T>
         ::prnt()
{
  for(int i = 0; i < n; i++)
  {
    for(int j = 0; j < m; j++)
      cout << setw(6)
           << A[i * m + j];
    cout << endl;
  }
  cout << endl;
}

#endif // _matrix_class

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

int main()
{
  // Wczytujemy dane
  // dla macierzy

  SetConsoleOutputCP(CP_UTF8);
  SetConsoleCP(CP_UTF8);

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

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

  // Tworzymy macierz wyniku
  matrix<int> C(A.n,B.m);

  cout << "\nMnożenie macierzy\n"
          "-----------------\n\n";
  cout << "Macierz A["
       << A.n
       << " x "
       << A.m
       << "]:\n";

  A.prnt();

  cout << "Macierz B["
       << B.n
       << " x "
       << B.m
       << "]:\n";

  B.prnt();

  // Mnożymy macierz A
  // przez macierz B
  // i wynik wpisujemy
  // do macierzy C
  C.mul(A,B);

  cout
  << "Wynik mnożenia w macierzy C["
  << C.n << " x " << C.m << "]:\n";

  C.prnt();

  system("pause");
  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 A[3 x 4]:
     0     2     4     6
     8    10    12    14
    16    18    20    22

Macierz B[4 x 5]:
     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 C[3 x 5]:
   292   316   340   364   388
   804   892   980  1068  1156
  1316  1468  1620  1772  1924

Python (dodatek)

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

# Definicja klasy
class Matrix:

    # Konstruktor tworzy
    # macierz z danych
    # z wejścia
    #-------------------
    def __init__(self, r=None, c=None):
        # Jeśli podano wymiary,
        # to tworzymy macierz
        # o tych wymiarach
        if (r is not None and
            c is not None):
            self.n = r
            self.m = c
            self.a = [[0
             for i in range(self.m)]
             for j in range(self.n)]
        else:
            # Jeśli nie podano wymiarów,
            # to wczytujemy dane 
            # Odczytujemy 2 liczby
            # z pierwszego wiersza
            # - to wymiary macierzy
            x = input().split()

            # Wymiary zapamiętujemy
            # w atrybutach obiektu
            # wiersze
            self.n = int(x[0])
            # kolumny
            self.m = int(x[1])
            
            # Odczytujemy n wierszy
            # i tworzymy z nich macierz
            self.a = [[int(el)
             for el in input().split()]
             for _ in range(self.n)]

    # Mnoży macierze
    #---------------
    def mul(self,a,b):
        
        for i in range(self.n):
            for j in range(self.m):
                sm = 0 # Suma częściowa
                for k in range(a.m):
                    sm += (a.a[i][k] *
                           b.a[k][j])
                self.a[i][j] = sm

    # Wypisuje zawartość
    # macierzy
    #-------------------
    def prnt(self):
        for i in range(self.n):
            for j in range(self.m):
                print(
                f"{self.a[i][j]:6}",
                end="")
            print()
        print()

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

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

a = Matrix()
b = Matrix()

# Tworzymy macierz wyniku
c = Matrix(a.n,b.m)

print("\nMnożenie macierzy\n"
      "-----------------\n")

print(f"Macierz a[{a.n} x {a.m}]:")
a.prnt()

print(f"Macierz b[{b.n} x {b.m}]:")
b.prnt()

# Mnożymy macierz a
# przez macierz b
# i wynik wpisujemy
# do macierzy c
print(f"Wynik mnożenia w "
      f"macierzy c[{c.n} x {c.m}]:")
c.mul(a,b)
c.prnt()

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

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		?	?	?	?	?