Multiplica dos matrices en C++

Este artículo explicará varios métodos de cómo multiplicar dos matrices en C++.

Utilice la implementación en serie para multiplicar dos matrices en C++

La multiplicación de matrices es una de las operaciones más utilizadas en una amplia gama de soluciones de ingeniería. Por lo tanto, existen varios algoritmos para mejorar el rendimiento en diferentes plataformas de hardware. Estos algoritmos a menudo utilizan programación concurrente así como mosaico de matrices para acelerar la multiplicación de matrices. En este caso, sin embargo, implementamos un algoritmo sencillo que se ejecuta en serie sin optimizaciones explícitas.

Al principio, necesitamos implementar algunas funciones de utilidad para ayudar a asignar e inicializar matrices para operar. Tenga en cuenta que estamos implementando el código para que el programador pueda modificar los enteros constantes ROW y COL para especificar las dimensiones del array. La función allocateMatrix asigna el array de matrices e inicializa elementos con valores cero. A continuación, se llama a la función initilizeMatrix que genera números aleatorios en el rango - [0, 100) y los almacena como elementos del array. Observe que también hay una función que imprime los elementos del array en la secuencia cout para verificar los resultados del cálculo.

La función multiplyMatrix implementa un simple bucle for anidado triple para multiplicar dos matrices y almacenar los resultados en la tercera matriz preasignada. Las dimensiones del array de resultado se toman de las primeras filas del array y las segundas columnas del array. Tenga en cuenta que el orden de los bucles es muy importante para el rendimiento de la multiplicación. Por ejemplo, si movemos la declaración for más interna en el medio, se espera un aumento de rendimiento casi garantizado. La mejora del rendimiento se debe a las memorias caché que se encuentran en casi todas las CPU contemporáneas. La memoria caché es más rápida que la memoria principal y almacena bloques de memoria contiguos cuando se recuperan los datos. Por lo tanto, la siguiente recuperación de datos puede realizarse desde las propias memorias caché.

#include <iomanip>
#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::setw;
using std::vector;

constexpr int ROW = 2;
constexpr int COL = 3;

void initilizeMatrix(int **m, int row, int col) {
  for (auto i = 0; i < row; ++i) {
    for (auto j = 0; j < col; ++j) {
      m[i][j] = rand() % 100;
    }
  }
}

void printMatrix(int **m, int row, int col) {
  for (auto i = 0; i < row; ++i) {
    for (auto j = 0; j < col; ++j) {
      cout << setw(5) << m[i][j] << "; ";
    }
    cout << endl;
  }
}

int **allocateMatrix(int row, int col) {
  int **matrix = new int *[row];
  for (int i = 0; i < row; ++i) {
    matrix[i] = new int[col]{0};
  }
  return matrix;
}

int deallocateMatrix(int **matrix, int row) {
  for (int i = 0; i < row; ++i) {
    delete matrix[i];
  }
  delete[] matrix;
  return 0;
}

int **multiplyMatrix(int **m1, int row1, int col1, int **m2, int row2,
                     int col2) {
  if (col1 != row2) return nullptr;

  auto ret = allocateMatrix(row1, col2);

  int i, j, k;

  for (i = 0; i < row1; i++) {
    for (j = 0; j < col2; j++) {
      for (k = 0; k < col1; k++) {
        ret[i][j] += m1[i][k] * m2[k][j];
      }
    }
  }

  return ret;
}

int main() {
  int **matrix1 = allocateMatrix(ROW, COL);
  int **matrix2 = allocateMatrix(COL, ROW);

  initilizeMatrix(matrix1, ROW, COL);
  initilizeMatrix(matrix2, COL, ROW);

  printMatrix(matrix1, ROW, COL);
  cout << endl;
  printMatrix(matrix2, COL, ROW);

  auto result = multiplyMatrix(matrix1, ROW, COL, matrix2, COL, ROW);

  cout << endl;
  printMatrix(result, ROW, ROW);

  deallocateMatrix(matrix1, ROW);
  deallocateMatrix(matrix2, COL);
  deallocateMatrix(result, ROW);

  return EXIT_SUCCESS;
}

Producción :

83;    86;    77;
15;    93;    35;

86;    92;
49;    21;
62;    27;

16126; 11521;
8017;  4278;

Finalmente, es importante liberar todos los recursos de memoria utilizados por las matrices antes de que el programa salga. La función deallocateMatrix se implementa de modo que toma un puntero de array y filas en él para eliminar cada elemento del objeto. Observe que el array de resultados asignada en el ámbito de la función multiplyMatrix también debe desasignarse explícitamente.