0 / 0 / 0
Регистрация: 30.12.2014
Сообщений: 120
1

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

11.03.2020, 13:58. Показов 338. Ответов 6
Метки нет (Все метки)

Author24 — интернет-сервис помощи студентам
Добрый день, форумчане. Подскажите, пожалуйста, как правильно написать условие для компиляции следующего задания:
нужно перемножить две матрицы (допустим, 4х4). В каждом элементе основных матриц, находится ещё матрица. Очень буду признателен за любую помощь. Заранее благодарю.
Миниатюры
Перемножение двух матриц, в элементах которых есть ещё матрица  
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
11.03.2020, 13:58
Ответы с готовыми решениями:

Перемножение двух матриц.
Есть задание: Прочитать две матрицы с клавиатуры (используя одну статическую функцию), проверить...

Перемножение двух матриц
Yo. У меня проблема с перемножением. Код конечно же написал, но вот в чем проблема. Когда я ввожу...

Перемножение двух матриц
нужна прога перемножающая 2 матрицы на языке С матрицы должны вводиться с клавиатуры и...

Перемножение двух матриц
Здравствуйте, выполняю для саморазвития не большой пример по перемножению двух матриц на C#. И...

6
6085 / 3445 / 1400
Регистрация: 07.02.2019
Сообщений: 8,755
11.03.2020, 14:17 2
Шаблоны
0
6085 / 3445 / 1400
Регистрация: 07.02.2019
Сообщений: 8,755
12.03.2020, 17:35 3
Труляля, если не упарываться в оптимизацию, то можно так:
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
}
0
0 / 0 / 0
Регистрация: 30.12.2014
Сообщений: 120
15.03.2020, 14:20  [ТС] 4
Цитата Сообщение от 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
}
Относительно понятно, спасибо. Но не могли бы вы объяснить, пожалуйста, как будет происходить умножение матриц, которые находятся в каждых элементах основных матриц, которые нужно перемножить между собой.
0
6085 / 3445 / 1400
Регистрация: 07.02.2019
Сообщений: 8,755
15.03.2020, 14:26 5
Цитата Сообщение от Труляля Посмотреть сообщение
Но не могли бы вы объяснить, пожалуйста, как будет происходить умножение матриц, которые находятся в каждых элементах основных матриц, которые нужно перемножить между собой.
так же как и внешних... У нас есть шаблон функции преремножения, для внешних и внутренних матриц будет сгенерирован свой экземпляр функции
Цитата Сообщение от Труляля Посмотреть сообщение
result[i][j] = result[i][j] + lh[i][k] * rh[k][j];
для матриц operator+ и operator* у нас определён, а для double он встроен
0
0 / 0 / 0
Регистрация: 30.12.2014
Сообщений: 120
18.04.2020, 19:21  [ТС] 6
Цитата Сообщение от 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
}
Отложил этот вопрос из-за нехватки времени, а теперь снова возвращаясь к данному заданию, не могу понять каков будет результат выполнения действия: если уножение двух матриц - понятно, ответ - одна матрица (результативная). А если матрица , в элементах которых тоже матрица, то каков итог и как это выведится?
0
6085 / 3445 / 1400
Регистрация: 07.02.2019
Сообщений: 8,755
18.04.2020, 19:27 7
Цитата Сообщение от Труляля Посмотреть сообщение
то каков итог
Там комментарии есть:
Цитата Сообщение от zayats80888 Посмотреть сообщение
C++
1
2
auto C = A * B; // результат - матрица 2x2 матриц 2х2
auto D = B * A; // результат - матрица 3х3 матриц 2х2
Цитата Сообщение от Труляля Посмотреть сообщение
и как это выведится?
И на это то же комментарий есть:
Цитата Сообщение от zayats80888 Посмотреть сообщение
C++
1
// как информативно вывести результат на экран, даже голову забивать не хочу...

Не по теме:

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

0
18.04.2020, 19:27
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
18.04.2020, 19:27
Помогаю со студенческими работами здесь

Перемножение двух матриц
Собственно задачка: Написать программу перемножения двух матриц. Найти вид функции сложности...

Перемножение двух матриц
public static int MultiplyMatrixs(int arrayA, int arrayB) { int array = new...

Перемножение двух матриц
Ребята, нужно составить программу перемножения двух матриц. При этом программа обязательно должна...

Перемножение двух матриц
В шапке ошибся задание : Заменить в строке принятое в Си обозначение символа с заданным кодом...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
7
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru