Question

对于学校的数学课，我需要创建一个用矩阵做某事（只是任何事情）的应用程序。我决定创建一个矩阵计算器。我有一个Matrix类，它包含一个2D数组，一个行整数和一个列整数。我创建了以下函数来乘以两个矩阵：

public: Matrix* multiply(Matrix* other)
{
  Matrix* temp = new Matrix(other->r, other->c);
  for(int i = 0; i < this->r; i++)
  {
    for(int j = 0; j < this->c; j++)
    {
      for(int k = 0; k < other->c; k++)
        temp->mat[i][j] += this->mat[i][k] * other->mat[k][j];
    }
  }
  return temp;
}

这非常有效，但前提是我将矩阵乘以相同的尺寸（例如Mat4x4 * Mat4x4或Mat2x4 * Mat2x4）。我知道我不能将Mat4x4与Mat9X2或任何东西相乘，但我知道第二个矩阵的列应该等于第一个矩阵的行（所以Mat2x2应该能够乘以Mat2x1）并且答案将具有第二矩阵的维度。我怎么能（或应该）制作这个函数，以便将矩阵乘以相同且不同的尺寸？

提前致谢

Answer 1

您的计划的解决方案是使临时维度不是其他维度而是this->r，other->c，以便使矩阵乘法的输出有效。

希望这有帮助。

Answer 2

以下代码包含一个PostObject类实现，旨在显示C ++的一些功能（如唯一指针，随机数和流格式）。当我想解释一下语言时，我经常使用它。也许它可以帮助你。

Matrix

可能的输出：

#include <cassert>
#include <iostream>
#include <iomanip>
#include <memory>
#include <random>

// Pedagogical implementation of matrix type.
class Matrix {

 public:

  // Create a rows-by-cols matrix filled with random numbers in (-1, 1).
  static Matrix Random(std::size_t rows, std::size_t cols) {

    Matrix m(rows, cols);

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<double> dis(-1, 1);

    for (std::size_t row = 0; row < rows; ++row) {
      for (std::size_t col = 0; col < cols; ++col) {
        m(row, col) = dis(gen);
      }
    }

    return m;
  }

  // Build an uninitialized rows-by-cols matrix.
  Matrix(std::size_t rows, std::size_t cols)
      : m_data { std::make_unique<double[]>(rows * cols) },
        m_rows { rows },
        m_cols { cols }
  {
    assert(m_rows > 0);
    assert(m_cols > 0);
  }

  // Return number of rows
  std::size_t rows() const { return m_rows; }

  // Return number of columns
  std::size_t cols() const { return m_cols; }

  // Value at (row, col)
  double operator()(std::size_t row, std::size_t col) const {
    assert(row < rows());
    assert(col < cols());
    return m_data[row * cols() + col];
  }

  // Reference to value at (row, col)
  double& operator()(std::size_t row, std::size_t col) {
    assert(row < rows());
    assert(col < cols());
    return m_data[row * cols() + col];
  }

  // Matrix multiply
  Matrix operator*(const Matrix& other) const {

    assert(cols() == other.rows());

    Matrix out(rows(), other.cols());

    for (std::size_t i = 0; i < rows(); ++i) {
      for (std::size_t j = 0; j < other.cols(); ++j) {
        double sum { 0 };
        for (std::size_t k = 0; k < cols(); ++k) {
          sum += (*this)(i, k) * other(k, j);
        }
        out(i, j) = sum;
      }
    }
    return out;
  }

 private:

  std::unique_ptr<double[]> m_data; // will cleanup after itself
  const std::size_t m_rows;
  const std::size_t m_cols;
};

// Pretty-print a matrix
std::ostream& operator<<(std::ostream& os, const Matrix& m) {
  os << std::scientific << std::setprecision(16);
  for (std::size_t row = 0; row < m.rows(); ++row) {
    for (std::size_t col = 0; col < m.cols(); ++col) {
      os << std::setw(23) << m(row, col) << " ";
    }
    os << "\n";
  }
  return os;
}

int main() {

  Matrix A = Matrix::Random(3, 4);
  Matrix B = Matrix::Random(4, 2);

  std::cout << "A\n" << A
            << "B\n" << B
            << "A * B\n" << (A * B);
}

Answer 3

它排除了行和列的顺序让我咂嘴'竹子。公式是正确的。抱歉不必要的帖子。

矩阵乘法（具有不同的尺寸）

3 个答案: