Сложение и вычитание матриц: примеры кода

Что такое матрица

Матрица — это прямоугольная таблица чисел, символов или выражений, упорядоченная в строках и столбцах. Матрицы используются в алгебре, компьютерной графике, обработке изображений, анализе данных и программировании. Первоначально их ввели для описания систем линейных уравнений.

Ключевая идея: операции сложения и вычитания выполняются поэлементно — элемент с индексом (i, j) новой матрицы получается как сумма или разность элементов с теми же индексами в двух исходных матрицах.

Правила сложения матриц

• Две матрицы можно складывать только если они одного порядка (одинаковые размеры строк и столбцов).
• Если размеры совпадают, складывают соответствующие элементы: C[i][j] = A[i][j] + B[i][j].

Важно: если размеры не совпадают, операция не определена — нельзя складывать 2x3 и 3x2 матрицы поэлементно.

C++: сложение двух матриц

Ниже — пример на C++ (элементарная реализация для матриц 3×3):

// C++ program for addition of two matrices

#include 
using namespace std;

// Размеры матрицы
#define size1 3
#define size2 3

void addMatrices(int mat1[][size2], int mat2[][size2], int result[][size2]) {
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

int main() {
    int mat1[size1][size2] = { {9, 8, 7}, {6, 8, 0}, {5, 9, 2} };
    int mat2[size1][size2] = { {4, 7, 6}, {8, 8, 2}, {7, 3, 5} };
    int result[size1][size2];

    addMatrices(mat1, mat2, result);

    cout << "mat1 + mat2 =" << endl;
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) cout << result[i][j] << " ";
        cout << endl;
    }
    return 0;
}

Вывод:

mat1 + mat2 =
13 15 13
14 16 2
12 12 7

Python: сложение двух матриц

Простой пример и важная ремарка по копированию списков:

# Python program for addition of two matrices

size1 = 3
size2 = 3

def addMatrices(mat1, mat2, result):
    for i in range(size1):
        for j in range(size2):
            result[i][j] = mat1[i][j] + mat2[i][j]

mat1 = [ [9, 8, 7], [6, 8, 0], [5, 9, 2] ]
mat2 = [ [4, 7, 6], [8, 8, 2], [7, 3, 5] ]

# ВАЖНО: корректное создание пустой матрицы результата
result = [ [0]*size2 for _ in range(size1) ]

addMatrices(mat1, mat2, result)

print("mat1 + mat2 =")
for i in range(size1):
    for j in range(size2):
        print(result[i][j], end=' ')
    print()

Вывод:

mat1 + mat2 =
13 15 13
14 16 2
12 12 7

Примечание: в исходной версии статьи использовалась конструкция result = mat1[:][:], которая НЕ создаёт независимую матрицу и приведёт к ошибочным изменениям исходных данных. Всегда создавайте отдельную матрицу результата.

Альтернатива: для быстрого и безопасного сложения используйте NumPy:

import numpy as np
A = np.array(mat1)
B = np.array(mat2)
C = A + B

Это даёт векторизованную операцию и защиту от ошибок с копированием.

C: сложение двух матриц

// C program for addition of two matrices
#include 

#define size1 3
#define size2 3

void addMatrices(int mat1[][size2], int mat2[][size2], int result[][size2]) {
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

int main() {
    int mat1[size1][size2] = { {9, 8, 7}, {6, 8, 0}, {5, 9, 2} };
    int mat2[size1][size2] = { {4, 7, 6}, {8, 8, 2}, {7, 3, 5} };
    int result[size1][size2];

    addMatrices(mat1, mat2, result);

    printf("mat1 + mat2 =\n");
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) printf("%d ", result[i][j]);
        printf("\n");
    }
    return 0;
}

Вывод совпадает с предыдущими примерами.

JavaScript: сложение двух матриц

// JavaScript program for addition of two matrices
let size1 = 3;
let size2 = 3;

function addMatrices(mat1, mat2, result) {
    for (let i = 0; i < size1; i++) {
        for (let j = 0; j < size2; j++) result[i][j] = mat1[i][j] + mat2[i][j];
    }
}

let mat1 = [ [9, 8, 7], [6, 8, 0], [5, 9, 2] ];
let mat2 = [ [4, 7, 6], [8, 8, 2], [7, 3, 5] ];
let result = new Array(size1);
for (let k = 0; k < size1; k++) result[k] = new Array(size2).fill(0);

addMatrices(mat1, mat2, result);

console.log("mat1 + mat2 =");
for (let i = 0; i < size1; i++) console.log(result[i].join(' '));

Правила вычитания матриц

• Две матрицы можно вычитать только если они одного порядка.
• Вычитание выполняется поэлементно: C[i][j] = A[i][j] - B[i][j].

C++: вычитание двух матриц

// C++ program for subtraction of two matrices
#include 
using namespace std;
#define size1 3
#define size2 3

void subtractMatrices(int mat1[][size2], int mat2[][size2], int result[][size2]) {
    for (int i = 0; i < size1; i++)
        for (int j = 0; j < size2; j++) result[i][j] = mat1[i][j] - mat2[i][j];
}

int main() {
    int mat1[size1][size2] = { {9, 8, 7}, {6, 8, 0}, {5, 9, 2} };
    int mat2[size1][size2] = { {4, 7, 6}, {8, 8, 2}, {7, 3, 5} };
    int result[size1][size2];

    subtractMatrices(mat1, mat2, result);

    cout << "mat1 - mat2 =" << endl;
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) cout << result[i][j] << " ";
        cout << endl;
    }
    return 0;
}

Вывод:

mat1 - mat2 =
5 1 1
-2 0 -2
-2 6 -3

Также доступны аналогичные примеры на Python, C и JavaScript (структура кода совпадает с операцией сложения, только знак меняется на “-“).

Практические советы и проверки

Важно: всегда проверяйте размеры (shape) матриц перед операцией.

• Проверка перед выполнением: если rows(A) != rows(B) или cols(A) != cols(B) — выдать ошибку/исключение.
• Для больших данных используйте библиотеки (NumPy, Eigen, Armadillo) — они реализуют векторизацию и оптимизацию памяти.
• Для целых типов следите за переполнением (overflow) при суммировании больших чисел.

Когда это не работает (контрпримеры)

• Нельзя складывать матрицы разных размеров (например, 2×3 и 3×2).
• Ошибка в Python из-за поверхностного копирования списков: result = mat1[:][:] не даёт независимую копию.
• При вещественных и комплексных данных убедитесь, что типы совместимы.

Ментальная модель

Представляйте матрицу как таблицу: сложение/вычитание — пройти по каждой ячейке и сложить/вычесть числа в одинаковых позициях. Сложность операции — O(rows * cols).

Таблица: быстрый шпаргалка по языкам

• C / C++: явные двоичные массивы, статические или динамические, ручная инициализация результата.
• Python: используйте списки списков или NumPy; будьте осторожны с копированием.
• JavaScript: массивы массивов, предварительно заполняйте массив результата.

Критерии приёмки

• Корректность: для любых матриц A и B одинаковой размерности функция возвращает C с C[i][j] = A[i][j] ± B[i][j].
• Безопасность: функция проверяет размеры и не модифицирует входные матрицы, если это не ожидается.
• Производительность: для больших матриц — использование векторных библиотек.

Тесты / примеры приёмки

1. A и B 3×3 (позитивный тест) — ожидаемый числовой результат (см. примеры выше).
2. A 2×3, B 3×2 — функция должна вернуть ошибку о несовпадении размерностей.
3. Матрицы с отрицательными и нулевыми элементами — результат корректно учитывает знаки.

Рольовые чек-листы

• Для студентов: проверьте понимание индексов и порядок матриц.
• Для разработчиков: добавьте проверки размеров и юнит-тесты.
• Для преподавателей: приведите примеры с ошибками (копирование в Python) и оптимизируйте решение.

Факт-бокс

• Операция: поэлементная.
• Время: O(m*n) для матрицы m×n.
• Типичный инструмент: NumPy (Python), Eigen (C++).

Краткая аннотация для соцсетей (100–200 слов)

В этом руководстве объяснено, как выполнять сложение и вычитание матриц: простые правила, примеры кода на C++, C, Python и JavaScript, а также практические советы. Вы узнаете, почему важно проверять размеры матриц, как избежать распространённых ошибок (например, при копировании списков в Python) и когда лучше использовать библиотеки вроде NumPy или Eigen. Включены также контрольные тесты и чек-листы для учащихся и разработчиков.

Важно: перед массовой обработкой больших матриц выбирайте векторизованные решения — они быстрее и надёжнее.

Итог

Сложение и вычитание матриц — базовые, но ключевые операции для линейной алгебры и программирования. Всегда проверяйте размерности, избегайте поверхностных копий данных и используйте оптимизированные библиотеки для больших задач.