在我正在编写的一个程序中，我需要重复地将两个矩阵相乘。由于其中一个矩阵的大小，这个操作需要一些时间，我想看看哪种方法最有效。矩阵的维数为(m x n)*(n x p)，其中m = n = 3和10^5 < p < 10^6。
除了Numpy，我假设它使用优化算法，每个测试都包含matrix multiplication的简单实现：

下面是我的各种实现：

Python

def dot_py(A,B):
    m, n = A.shape
    p = B.shape[1]

    C = np.zeros((m,p))

    for i in range(0,m):
        for j in range(0,p):
            for k in range(0,n):
                C[i,j] += A[i,k]*B[k,j] 
    return C

麻木

def dot_np(A,B):
    C = np.dot(A,B)
    return C

农巴

代码与Python代码相同，但在使用之前及时编译：

dot_nb = nb.jit(nb.float64[:,:](nb.float64[:,:], nb.float64[:,:]), nopython = True)(dot_py)

到目前为止，每个方法调用都使用timeit模块计时了10次。保持最佳结果。矩阵是使用np.random.rand(n,m)创建的。

C++

mat2 dot(const mat2& m1, const mat2& m2)
{
    int m = m1.rows_;
    int n = m1.cols_;
    int p = m2.cols_;

    mat2 m3(m,p);

    for (int row = 0; row < m; row++) {
        for (int col = 0; col < p; col++) {
            for (int k = 0; k < n; k++) {
                m3.data_[p*row + col] += m1.data_[n*row + k]*m2.data_[p*k + col];
            }
        }
    }

    return m3;
}

这里，mat2是我定义的一个自定义类，dot(const mat2& m1, const mat2& m2)是该类的友元函数。它使用Windows.h中的QPF和QPC进行计时，并使用MinGW和g++命令编译程序。同样，从10次执行中获得的最佳时间被保留。

结果

正如预期的那样，简单的Python代码较慢，但对于非常小的矩阵，它仍然优于Numpy。在最大的情况下，Numba比Numpy快30%。
我对C的结果感到惊讶，乘法比Numba多花了几乎一个数量级的时间。事实上，我预计这些需要类似的时间。
这就引出了我的主要问题：这是正常的吗？如果不是，为什么C比Numba慢？我刚开始学习C++，所以我可能做错了什么。如果是这样，我的错误是什么，或者我可以做些什么来提高代码的效率（除了选择一个更好的算法）？

编辑1

下面是mat2类的头文件。

#ifndef MAT2_H
#define MAT2_H

#include <iostream>

class mat2
{
private:
    int rows_, cols_;
    float* data_;

public: 
    mat2() {}                                   // (default) constructor
    mat2(int rows, int cols, float value = 0);  // constructor
    mat2(const mat2& other);                    // copy constructor
    ~mat2();                                    // destructor

    // Operators
    mat2& operator=(mat2 other);                // assignment operator

    float operator()(int row, int col) const;
    float& operator() (int row, int col);

    mat2 operator*(const mat2& other);

    // Operations
    friend mat2 dot(const mat2& m1, const mat2& m2);

    // Other
    friend void swap(mat2& first, mat2& second);
    friend std::ostream& operator<<(std::ostream& os, const mat2& M);
};

#endif

编辑2

正如许多人所建议的那样，使用优化标志是匹配Numba的缺失元素。下面是与以前的曲线相比的新曲线。标记为v2的曲线是通过切换两个内部循环获得的，并且显示出另外30%到50%的改进。