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.

Przykładowy program w języku C++

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

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;

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

int main()
{
    setlocale(LC_ALL,"");

    cout << "Tablica statyczna o rozmiarze 10x20" << endl
         << "-----------------------------------" << endl << endl;

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

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

    // Weświetlamy wyniki

    for(i = 0; i < 10; i++)
    {

        for(j = 0; j < 20; j++)cout << setw(3)<< A[i][j];
        cout << endl;
    }

    cout << endl;

    return 0;
}

Wynik

Tablica statyczna o rozmiarze 10x20
-----------------------------------

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.

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++:

Przykładowy program w języku C++

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

#include <iostream>
#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];

    setlocale(LC_ALL,"");

    cout << "Tablica dynamiczna o rozmiarze " << 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;
    }

    cout << endl;

    // Usuwamy tablice wierszy

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

    // Usuwamy tablicę wskaźników

    delete [] A;

    return 0;
}

Wynik

Tablica dynamiczna o rozmiarze 12x19
------------------------------------

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

Macierz może również zostać odwzorowana jako klasa języka C++. 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.

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.

Przykładowy program w języku C++

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

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;

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

#ifndef _matrix_class
    #define _matrix_class
    class matrix
    {
        private:
            int n,m;  // Rozmiar macierzy
            int * A;  // Elementy
        public:
            matrix(int r, int c); // Konstruktor
            ~matrix();            // Destruktor
            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_class

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

    setlocale(LC_ALL,"");

    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;

    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

Lepszym pomysłem jest wykorzystanie klasy szablonowej. Klasa szablonowa nie określa typu elementów - 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.

Przykładowy program w języku C++

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

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

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 n,m;  // Rozmiar macierzy
            T * A;    // Elementy
        public:
            matrix(int r, int c); // Konstruktor
            ~matrix();            // Destruktor
            void setv(int r, int c, T v);
            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_class

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

    setlocale(LC_ALL,"");

    cout << setprecision(2)<< fixed;
    cout << "Klasa szablonowa macierzy o rozmiarze " << 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;
    }

    cout << endl;

    return 0;
}

Wynik

Klasa szablonowa macierzy o rozmiarze 12x13
-------------------------------------------

8.40 8.88 4.15 1.27 2.23 5.34 6.05 5.91 7.75 6.53 6.92 0.58 0.24
1.01 2.01 6.73 4.22 8.37 4.53 7.18 2.58 9.83 7.24 4.40 4.09 2.83
7.34 9.16 5.37 0.04 7.90 0.38 0.02 9.60 8.33 1.45 8.97 5.95 8.09
3.31 8.59 5.02 2.99 4.04 6.39 4.76 6.70 7.69 5.96 8.54 6.21 5.00
2.14 2.55 7.51 7.34 1.31 0.74 4.13 6.64 7.95 7.63 4.91 6.78 5.03
2.59 8.26 9.01 8.17 3.84 1.33 8.87 8.77 3.80 1.63 1.80 6.70 5.81
1.81 0.43 7.87 9.33 1.05 8.98 3.40 1.15 8.70 1.86 1.76 8.26 7.28
0.30 9.20 0.64 2.78 1.57 2.18 8.97 0.18 2.54 9.10 0.05 7.61 2.92
0.13 0.87 0.76 0.58 2.92 6.16 2.54 8.96 7.55 6.84 6.64 1.27 4.10
5.87 3.61 4.50 7.66 5.22 9.93 1.97 2.49 4.83 3.83 5.78 7.92 0.50
7.69 5.46 3.37 0.10 3.01 0.57 0.68 4.88 1.74 2.69 0.73 3.01 5.29
6.00 5.70 3.86 0.25 6.60 8.99 9.83 8.55 0.54 2.07 4.44 5.58 1.42

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

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ą i wyświetla jej zawartość:

Przykładowy program w języku C++

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

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

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 n,m,s;  // Rozmiar macierzy
            T * A;    // Elementy
        public:
            matrix(int r, int c); // Konstruktor
            ~matrix();            // Destruktor
            void makeIdent(void); // Macierz jednostkowa
            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;
        s = n * m;
        A = new T [s];
    }

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

    // Tworzy macierz jednostkową
    //-------------------------
    template <class T> void matrix<T>::makeIdent()
    {
        int i;
        for(i = 0; i < s; i++)A[i] = (T)0;
        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_class

// 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 macierz kwadratową

    matrix<int> A(n,n);

    // Tworzymy macierz jednostkową

    A.makeIdent();

    // Wyświetlamy macierz

    setlocale(LC_ALL,"");

    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;
    }

    cout << endl;

    return 0;
}

Wynik

Macierz jednostkowa o rozmiarze 20x20
-------------------------------------

1 0 0 0 0 0 0 0 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 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 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 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 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 0
0 0 0 0 0 0 1 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
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 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 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 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 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 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

Następne dwie metody odczytują dane dla macierzy ze strumienia, Pierwsza metoda odczytuje dane z pliku dane.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.

Dane są skonstruowane następująco:

dwie pierwsze liczby określają rozmiar macierzy: n – liczba wierszy i m – liczba kolumn, są to liczby całkowite
za tymi liczbami musi wystąpić n × m danych dla poszczególnych wyrazów macierzy. Dane powinny być zorganizowane wierszami po m elementów w każdym wierszu. Pomiędzy elementami muszą być znaki spacji, odstępu lub nowego wiersza. 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 plik dane.txt do odpowiedniego katalogu.

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.

Przykładowy program w języku C++

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

#include <iostream>
#include <fstream>
#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 n,m,s;  // Rozmiar macierzy
            T * A;      // Elementy
        public:
            matrix();             // Konstruktor
            ~matrix();            // Destruktor
            T  getv(int r, int c);
            int rows();           // Zwraca liczbę wierszy macierzy
            int cols();           // Zwraca liczbę kolumn macierzy
    };

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

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

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

        s = n * m;

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

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

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

    // 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];
    }

    // Zwraca liczbę wierszy w macierzy
    //---------------------------------
    template <class T> int matrix<T>::rows()
    {
        return n;
    }

    // Zwraca liczbę kolumn w macierzy
    //---------------------------------
    template <class T> int matrix<T>::cols()
    {
        return m;
    }

#endif // _matrix_class

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

int main()
{
    // Tworzymy macierz

    matrix<int> A;

    // Wyświetlamy macierz

    int i,j;

    setlocale(LC_ALL,"");

    cout << "Macierz z pliku o rozmiarze " << A.rows()<< "x" << A.cols()<< endl
         << "---------------------------------" << endl << endl;
    for(i = 0; i < A.rows(); i++)
    {
        for(j = 0; j < A.cols(); j++)cout << setw(4)<< A.getv(i,j);
        cout << endl;
    }

    cout << endl;

    return 0;
}

Wynik

Macierz z pliku o rozmiarze 10x15
---------------------------------

   1   2   3   4   5   6   7   8   9   0   1   2   3   4   5
   7   0   9   6   4   7   2   5   3   1   0   2   8   2   3
   8   8   6   2   3   1   0   8   5   4   8   2   9   9   2
   9   6   9   2   3   2   1   9   6   8   2   3   4   5   1
   8   9   5   6   3   2   2   2   6 11   5   7   9 12   6
   0   7   8   2   7   3   5   5   1   8   9   3   3   2   0
   9   7   2   5   5   5   2   2   2   1   9   8   0   0   0
   4 444   7   6   8   9   2   3   6   8   8 888 92 43 15
   1   3 66 87 51 62 88 92 83 99 11 13   6 55   6
   1   2   3   4   5   6   7   8   9 10 11 12 13 14 15

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, Linuks 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

Przykładowy program w języku C++

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

#include <iostream>
#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 n,m,s;  // Rozmiar macierzy
            T * A;    // Elementy
        public:
            matrix();             // Konstruktor
            ~matrix();            // Destruktor
            T  getv(int r, int c);
            int rows();           // Zwraca liczbę wierszy macierzy
            int cols();           // Zwraca liczbę kolumn macierzy
    };

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

        s = n * m;

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

        for(int i = 0; i < s; i++)cin >> A[i]; // Wczytujemy wyrazy do 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];
    }

    // Zwraca liczbę wierszy w macierzy
    //---------------------------------
    template <class T> int matrix<T>::rows()
    {
        return n;
    }

    // Zwraca liczbę kolumn w macierzy
    //---------------------------------
    template <class T> int matrix<T>::cols()
    {
        return m;
    }

#endif // _matrix_class

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

int main()
{
    // Wyświetlamy macierz

    int i,j;

    setlocale(LC_ALL,"");

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

    // Tworzymy macierz z wczytaniem jej ze strumienia

    matrix<int> A;

    cout << endl
         << "Macierz ze strumienia o rozmiarze " << A.rows()<< "x" << A.cols()<< endl
         << "---------------------------------------" << endl << endl;
    for(i = 0; i < A.rows(); i++)
    {
        for(j = 0; j < A.cols(); j++)cout << setw(4)<< A.getv(i,j);
        cout << endl;
    }

    cout << endl;

    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 ze strumienia o rozmiarze 10x15
---------------------------------------

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

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

Przykładowy program w języku C++

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

#include <iostream>
#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

    setlocale(LC_ALL,"");

    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:

obrazek

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

Przykładowy program w języku C++

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

#include <iostream>
#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

    setlocale(LC_ALL,"");

    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 w języku C++

Wprowadzanie danych do macierzy

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