Перемножение двух матриц, в элементах которых есть ещё матрица

@Труляля · Регистрация: 30.12.2014

Студворк — интернет-сервис помощи студентам

Добрый день, форумчане. Подскажите, пожалуйста, как правильно написать условие для компиляции следующего задания:
нужно перемножить две матрицы (допустим, 4х4). В каждом элементе основных матриц, находится ещё матрица. Очень буду признателен за любую помощь. Заранее благодарю.

@zayats80888 · 11.03.2020, 14:17

Шаблоны

@zayats80888 · 12.03.2020, 17:35

Труляля, если не упарываться в оптимизацию, то можно так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <iostream>
#include <vector>
#include <cassert>
////////////////////////////////////////////////////////////////////////////////////////////////
// шаблон класса матрица
template<class T> class Matrix
{
public:
    Matrix() : m_rows(), m_cols(), m_data() {}
    Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols), m_data(rows * cols)
    {
        assert(m_rows && m_cols);
        assert(m_rows <= m_data.max_size() / m_cols);
    }
 
///////// Конструктор для демонстрационного кода в main, удали потом, он без проверок //////////
    Matrix(size_t rows, size_t cols, std::initializer_list<T> lst)                          ////
        : m_rows(rows), m_cols(cols), m_data(lst) {}                                        ////
////////////////////////////////////////////////////////////////////////////////////////////////
 
    size_t rows() const { return m_rows; }
    size_t cols() const { return m_cols; }
 
    T* operator[](size_t row) { return m_data.data() + m_cols * row; }
    const T* operator[](size_t row) const { return m_data.data() + m_cols * row; }
 
private:
    size_t m_rows;
    size_t m_cols;
    std::vector<T> m_data;
};
////////////////////////////////////////////////////////////////////////////////////////////////
// сложение матриц
template<class T>
Matrix<T> operator+(const Matrix<T>& lh, const Matrix<T>& rh)
{
    Matrix<T> result;
    // возможность складывать "пустые" дефолтные матрицы
    if (lh.rows() == 0 && lh.cols() == 0)
        result = rh;
    else if (rh.rows() == 0 && rh.cols() == 0)
        result = lh;
    else
    {   
        // если ни одна матрица не дефолтная
        assert(lh.rows() == rh.rows());
        assert(lh.cols() == rh.cols());
 
        result = Matrix<T>(lh.rows(), lh.cols());
        for (size_t i = 0; i < lh.rows(); ++i)
        {
            for (size_t j = 0; j < lh.cols(); ++j)
            {
                result[i][j] = lh[i][j] + rh[i][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
// умножение матриц
template<class T>
Matrix<T> operator*(const Matrix<T>& lh, const Matrix<T>& rh)
{
    assert(lh.cols() == rh.rows());
    auto result = Matrix<T>(lh.rows(), rh.cols());
    for (size_t i = 0; i < lh.rows(); ++i)
    {
        for (size_t j = 0; j < rh.cols(); ++j)
        {
            for (size_t k = 0; k < lh.cols(); ++k)
            {
                result[i][j] = result[i][j] + lh[i][k] * rh[k][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    // матрица 2x3 матриц 2х2
    Matrix<Matrix<double>> A
    {
        2, 3,
        {
            { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 8, 9, 10, 11 } },
            { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 11, 10, 9, 8 } },
        }
    };
    // матрица 3х2 матриц 2х2
    Matrix<Matrix<double>> B
    {
        3, 2,
        {
            { 2, 2, { 0, 1, 2, 3 } },       { 2, 2, { 4, 5, 6, 7 } },
            { 2, 2, { 4, 5, 6, 7 } },       { 2, 2, { 0, 1, 2, 3 } },
            { 2, 2, { 8, 9, 10, 11 } },     { 2, 2, { 11, 10, 9, 8 } }
        }
    };
    // как информативно вывести результат на экран, даже голову забивать не хочу...
    auto C = A * B; // результат - матрица 2x2 матриц 2х2
    auto D = B * A; // результат - матрица 3х3 матриц 2х2
}

@Труляля · 15.03.2020, 14:20 **[ТС]**

Сообщение от zayats80888

Труляля, если не упарываться в оптимизацию, то можно так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <iostream>
#include <vector>
#include <cassert>
////////////////////////////////////////////////////////////////////////////////////////////////
// шаблон класса матрица
template<class T> class Matrix
{
public:
    Matrix() : m_rows(), m_cols(), m_data() {}
    Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols), m_data(rows * cols)
    {
        assert(m_rows && m_cols);
        assert(m_rows <= m_data.max_size() / m_cols);
    }
 
///////// Конструктор для демонстрационного кода в main, удали потом, он без проверок //////////
    Matrix(size_t rows, size_t cols, std::initializer_list<T> lst)                          ////
        : m_rows(rows), m_cols(cols), m_data(lst) {}                                        ////
////////////////////////////////////////////////////////////////////////////////////////////////
 
    size_t rows() const { return m_rows; }
    size_t cols() const { return m_cols; }
 
    T* operator[](size_t row) { return m_data.data() + m_cols * row; }
    const T* operator[](size_t row) const { return m_data.data() + m_cols * row; }
 
private:
    size_t m_rows;
    size_t m_cols;
    std::vector<T> m_data;
};
////////////////////////////////////////////////////////////////////////////////////////////////
// сложение матриц
template<class T>
Matrix<T> operator+(const Matrix<T>& lh, const Matrix<T>& rh)
{
    Matrix<T> result;
    // возможность складывать "пустые" дефолтные матрицы
    if (lh.rows() == 0 && lh.cols() == 0)
        result = rh;
    else if (rh.rows() == 0 && rh.cols() == 0)
        result = lh;
    else
    {   
        // если ни одна матрица не дефолтная
        assert(lh.rows() == rh.rows());
        assert(lh.cols() == rh.cols());
 
        result = Matrix<T>(lh.rows(), lh.cols());
        for (size_t i = 0; i < lh.rows(); ++i)
        {
            for (size_t j = 0; j < lh.cols(); ++j)
            {
                result[i][j] = lh[i][j] + rh[i][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
// умножение матриц
template<class T>
Matrix<T> operator*(const Matrix<T>& lh, const Matrix<T>& rh)
{
    assert(lh.cols() == rh.rows());
    auto result = Matrix<T>(lh.rows(), rh.cols());
    for (size_t i = 0; i < lh.rows(); ++i)
    {
        for (size_t j = 0; j < rh.cols(); ++j)
        {
            for (size_t k = 0; k < lh.cols(); ++k)
            {
                result[i][j] = result[i][j] + lh[i][k] * rh[k][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    // матрица 2x3 матриц 2х2
    Matrix<Matrix<double>> A
    {
        2, 3,
        {
            { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 8, 9, 10, 11 } },
            { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 11, 10, 9, 8 } },
        }
    };
    // матрица 3х2 матриц 2х2
    Matrix<Matrix<double>> B
    {
        3, 2,
        {
            { 2, 2, { 0, 1, 2, 3 } },       { 2, 2, { 4, 5, 6, 7 } },
            { 2, 2, { 4, 5, 6, 7 } },       { 2, 2, { 0, 1, 2, 3 } },
            { 2, 2, { 8, 9, 10, 11 } },     { 2, 2, { 11, 10, 9, 8 } }
        }
    };
    // как информативно вывести результат на экран, даже голову забивать не хочу...
    auto C = A * B; // результат - матрица 2x2 матриц 2х2
    auto D = B * A; // результат - матрица 3х3 матриц 2х2
}

Относительно понятно, спасибо. Но не могли бы вы объяснить, пожалуйста, как будет происходить умножение матриц, которые находятся в каждых элементах основных матриц, которые нужно перемножить между собой.

@zayats80888 · 15.03.2020, 14:26

Сообщение от Труляля

Но не могли бы вы объяснить, пожалуйста, как будет происходить умножение матриц, которые находятся в каждых элементах основных матриц, которые нужно перемножить между собой.

так же как и внешних... У нас есть шаблон функции преремножения, для внешних и внутренних матриц будет сгенерирован свой экземпляр функции

Сообщение от Труляля

result[i][j] = result[i][j] + lh[i][k] * rh[k][j];

для матриц operator+ и operator* у нас определён, а для double он встроен

@Труляля · 18.04.2020, 19:21 **[ТС]**

Сообщение от zayats80888

Труляля, если не упарываться в оптимизацию, то можно так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <iostream>
#include <vector>
#include <cassert>
////////////////////////////////////////////////////////////////////////////////////////////////
// шаблон класса матрица
template<class T> class Matrix
{
public:
    Matrix() : m_rows(), m_cols(), m_data() {}
    Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols), m_data(rows * cols)
    {
        assert(m_rows && m_cols);
        assert(m_rows <= m_data.max_size() / m_cols);
    }
 
///////// Конструктор для демонстрационного кода в main, удали потом, он без проверок //////////
    Matrix(size_t rows, size_t cols, std::initializer_list<T> lst)                          ////
        : m_rows(rows), m_cols(cols), m_data(lst) {}                                        ////
////////////////////////////////////////////////////////////////////////////////////////////////
 
    size_t rows() const { return m_rows; }
    size_t cols() const { return m_cols; }
 
    T* operator[](size_t row) { return m_data.data() + m_cols * row; }
    const T* operator[](size_t row) const { return m_data.data() + m_cols * row; }
 
private:
    size_t m_rows;
    size_t m_cols;
    std::vector<T> m_data;
};
////////////////////////////////////////////////////////////////////////////////////////////////
// сложение матриц
template<class T>
Matrix<T> operator+(const Matrix<T>& lh, const Matrix<T>& rh)
{
    Matrix<T> result;
    // возможность складывать "пустые" дефолтные матрицы
    if (lh.rows() == 0 && lh.cols() == 0)
        result = rh;
    else if (rh.rows() == 0 && rh.cols() == 0)
        result = lh;
    else
    {   
        // если ни одна матрица не дефолтная
        assert(lh.rows() == rh.rows());
        assert(lh.cols() == rh.cols());
 
        result = Matrix<T>(lh.rows(), lh.cols());
        for (size_t i = 0; i < lh.rows(); ++i)
        {
            for (size_t j = 0; j < lh.cols(); ++j)
            {
                result[i][j] = lh[i][j] + rh[i][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
// умножение матриц
template<class T>
Matrix<T> operator*(const Matrix<T>& lh, const Matrix<T>& rh)
{
    assert(lh.cols() == rh.rows());
    auto result = Matrix<T>(lh.rows(), rh.cols());
    for (size_t i = 0; i < lh.rows(); ++i)
    {
        for (size_t j = 0; j < rh.cols(); ++j)
        {
            for (size_t k = 0; k < lh.cols(); ++k)
            {
                result[i][j] = result[i][j] + lh[i][k] * rh[k][j];
            }
        }
    }
    return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    // матрица 2x3 матриц 2х2
    Matrix<Matrix<double>> A
    {
        2, 3,
        {
            { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 8, 9, 10, 11 } },
            { 2, 2, { 4, 5, 6, 7 } },   { 2, 2, { 0, 1, 2, 3 } },   { 2, 2, { 11, 10, 9, 8 } },
        }
    };
    // матрица 3х2 матриц 2х2
    Matrix<Matrix<double>> B
    {
        3, 2,
        {
            { 2, 2, { 0, 1, 2, 3 } },       { 2, 2, { 4, 5, 6, 7 } },
            { 2, 2, { 4, 5, 6, 7 } },       { 2, 2, { 0, 1, 2, 3 } },
            { 2, 2, { 8, 9, 10, 11 } },     { 2, 2, { 11, 10, 9, 8 } }
        }
    };
    // как информативно вывести результат на экран, даже голову забивать не хочу...
    auto C = A * B; // результат - матрица 2x2 матриц 2х2
    auto D = B * A; // результат - матрица 3х3 матриц 2х2
}

Отложил этот вопрос из-за нехватки времени, а теперь снова возвращаясь к данному заданию, не могу понять каков будет результат выполнения действия: если уножение двух матриц - понятно, ответ - одна матрица (результативная). А если матрица , в элементах которых тоже матрица, то каков итог и как это выведится?

@zayats80888 · 18.04.2020, 19:27

Сообщение от Труляля

то каков итог

Там комментарии есть:

Сообщение от zayats80888

C++
1
2
auto C = A * B; // результат - матрица 2x2 матриц 2х2
auto D = B * A; // результат - матрица 3х3 матриц 2х2

Сообщение от Труляля

и как это выведится?

И на это то же комментарий есть:

Сообщение от zayats80888

C++
1
// как информативно вывести результат на экран, даже голову забивать не хочу...

Не по теме:

P.S. И не нужно цитировать всё сообщение, да еще и с кодом

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Синхронизация спрайтов SDL3 и тел Box2D 8Observer8 04.03.2026 Содержание блога Финальная демка в браузере. Итоговый код: finish-sync-physics-sprites-sdl3-c. zip На первой гифке отладочные линии отключены, а на второй включены:. . .	SDL3 для Web (WebAssembly): Идентификация объектов на Box2D v3 - использование userData и событий коллизий 8Observer8 02.03.2026 Содержание блога Финальная демка в браузере. Итоговый код: finish-collision-events-sdl3-c. zip https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11680&d=1772460536 Одним из. . .	Реалии Hrethgir 01.03.2026 Нет, я не закончил до сих пор симулятор. Эта задача сложнее. Не получилось уйти в плавсостав, но оно и к лучшему, возможно. Точнее получалось - но сварщиком в палубную команду, а это значит, в моём. . .	Ритм жизни kumehtar 27.02.2026 Иногда приходится жить в ритме, где дел становится всё больше, а вовлечения в происходящее — всё меньше. Плотный график не даёт вниманию закрепиться ни на одном событии. Утро начинается с быстрых,. . .
SDL3 для Web (WebAssembly): Сборка библиотек: SDL3, Box2D, FreeType, SDL3_ttf, SDL3_mixer и SDL3_image из исходников с помощью CMake и Emscripten 8Observer8 27.02.2026 Недавно вышла версия 3. 4. 2 библиотеки SDL3. На странице официальной релиза доступны исходники, готовые DLL (для x86, x64, arm64), а также библиотеки для разработки под Android, MinGW и Visual Studio. . . .	SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами 8Observer8 20.02.2026 Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .	Конвертировать закладки radiotray-ng в m3u-плейлист damix 19.02.2026 Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .	Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI Eddy_Em 18.02.2026 Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .

@Труляля 0 / 0 / 0 Регистрация: 30.12.2014 Сообщений: 121

	Перемножение двух матриц, в элементах которых есть ещё матрица 11.03.2020, 13:58. Показов 469. Ответов 6 Метки нет (Все метки) Добрый день, форумчане. Подскажите, пожалуйста, как правильно написать условие для компиляции следующего задания: нужно перемножить две матрицы (допустим, 4х4). В каждом элементе основных матриц, находится ещё матрица. Очень буду признателен за любую помощь. Заранее благодарю. Миниатюры 0

@zayats80888 6352 / 3523 / 1428 Регистрация: 07.02.2019 Сообщений: 8,995
	11.03.2020, 14:17
	Шаблоны 0