矩阵乘积计算（Strassen）

最新推荐文章于 2021-12-26 16:35:59 发布
最新推荐文章于 2021-12-26 16:35:59 发布
阅读量2.8k 收藏 10
点赞数
分类专栏： 算法 c语言 c++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/grayondream/article/details/68195304
版权
c++ 同时被 3 个专栏收录
42 篇文章 0 订阅
订阅专栏
算法
23 篇文章 2 订阅
订阅专栏
c语言
11 篇文章 1 订阅
订阅专栏

矩阵乘积计算（Strassen）

问题描述

​ 已知A，B两个矩阵计算其乘积C？

矩阵乘积数学公式：

​ 假设存在两个矩阵A为m×n矩阵，B为k×l矩阵，若需要计算AB则必须n=k，若需要计算BA必须l=m否则无法进行计算，先假定n=k即B为n×l矩阵则AB的结果为一个m×l的矩阵并且该矩阵每个点的元素的值表示为 Cij 则：

这里写图片描述

这里写图片描述

方法一：直接计算

​ 直接利用多重for循环求出相关矩阵对应的点的值即可

//矩阵的数据结构,随机矩阵，非特殊矩阵
struct array
{
    int **data;                 //数据域
    int row;
    int col;
};

/**
 *  初始化矩阵元素，用随机数填充
 *  只为研究算法因此为进行相关的内存检查
 *  flag用来标记是否生成空矩阵，即元素全部为0的矩阵
 */
void init_array(struct array *ptr,const int row,const int col,int flag)
{
    int i = 0,j = 0;
    ptr->data = (int **)malloc(sizeof(int)*row);                                    //？？内存分配
    for (i = 0; i < row; i++)
    {
        *(ptr->data + i) = (int*)malloc(sizeof(int)*col);                           //？？内存分配
    }

    ptr->col = col;
    ptr->row = row;
    srand(time(NULL));
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (flag)
            {
                ptr->data[i][j] = rand() % ARRAY_PRCE;
            }
            else
            {
                ptr->data[i][j] = 0;
            }
        }
    }
}

/**
 *  打印矩阵元素
 */
void print_array(const struct array *ptr, const char *msg)
{
    int i, j;
    printf("%s\n", msg);
    for (i = 0; i < ptr->row; i++)
    {
        for (j = 0; j < ptr->col; j++)
        {
            printf("%4d", ptr->data[i][j]);
        }

        printf("\n");
    }
}
/**
 *  销毁内存
 */
void delete_array(struct array *ptr)
{
    int i = 0;
    for (i = 0; i < ptr->row; i++)
    {
        free(*(ptr->data + i));
        *(ptr->data + i) = NULL;
    }

    free(ptr->data);
}

/*******************************************************************************************

*******************************************************************************************/

/**
*   矩阵乘法求解  
*   问题描述：已知两个可以进行相乘的矩阵，求的乘积后的结果
*/

/**
*   方法一：暴力直接求解  
*   利用矩阵乘法规则直接进行求解罗列出每个点的值求的最终的矩阵
*/
struct array mult_array(const struct array *ptr1, const struct array *ptr2)
{
    int i = 0;
    int j = 0;
    int k = 0;
    struct array ptr;
    if (ptr1->col != ptr2->row)                         //检查是否符合可以进行乘积的要求
    {
        return;
    }

    init_array(&ptr, ptr1->row, ptr2->col, 0);
    for (i = 0; i < ptr.row;i ++)
    {
        for (j = 0; j < ptr.col; j++)
        {
            for (k = 0; k < ptr1->col; k++)
            {
                ptr.data[i][j] += ptr1->data[i][k] * ptr2->data[k][j];
            }
        }
    }

    return ptr;
}

执行效果

这里写图片描述

时间复杂度为O( n3 )

方法二：分治算法

​ 将矩阵分解为一个个小矩阵进行计算然后将计算结果合并得到相关的结果。源于矩阵服从分配率和结合律，并不支持交换律。

​ 三个矩阵本身就可以写成下面的格式

这里写图片描述

​ 那么相关的计算可以写成

这里写图片描述

​ 同理A11等一些子矩阵也可以写成相关的子矩阵，就这样将矩阵不断分解为小矩阵进行计算，最后归并为一个矩阵。

​ 时间复杂度为O( n3 )

/**
 *  方法二：利用分治思想进行求解
 *  存在问题无法解决不同类型的矩阵的问题，要求矩阵的行列必须为2的n次方，若不符合要求可以使用
 *  补0来构造相关的矩阵
 */
Matrix* Matrix::merge_calc(const Matrix& x)
{
    if (x.row == 1)             //当前的矩阵为单个的元素
    {
        Matrix *ptr = new Matrix(x.row, x.col);
        ptr->clear((this->getElem(0, 0))*(x.getElem(0, 0)));
        return ptr;
    }

    //将第一个矩阵分解为四个子矩阵
    Matrix A11(0,0,row/2,col/2,*this);
    Matrix A12(row / 2, 0, row, col / 2, *this);
    Matrix A21(0, col / 2, row / 2, col, *this);
    Matrix A22(row / 2, col / 2, row, col, *this);
    //将第二个矩阵分解为四个子矩阵
    Matrix B11(0, 0, row / 2, col / 2, x);
    Matrix B12(row / 2, 0, row, col / 2, x);
    Matrix B21(0, col / 2, row / 2, col, x);
    Matrix B22(row / 2, col / 2, row, col, x);

    Matrix *C11 = Matrix::add(A11.merge_calc(B11), A12.merge_calc(B21));
    Matrix *C12 = Matrix::add(A11.merge_calc(B12), A12.merge_calc(B22));
    Matrix *C21 = Matrix::add(A21.merge_calc(B11), A22.merge_calc(B21));
    Matrix *C22 = Matrix::add(A21.merge_calc(B12), A22.merge_calc(B22));

    //将C11，C12，C21，C22合并为一个完整的矩阵
    Matrix* ptr = Matrix::merge(C11, C12, C21, C22);

    return ptr;
}

方法三：Strassen算法

​ Strassen算法同样是使用分治的思想解决问题，只不过，不同的是当矩阵的阶很大时就会采取一个递推式进行计算相关递推式为：

                            S1 = B12 - B22
                            S2 = A11 + A12
                            S3 = A21 + A22
                            S4 = B21 - B11
                            S5 = A11 + A22
                            S6 = B11 + B22
                            S7 = A12 - A22
                            S8 = B21 + B22
                            S9 = A11 - A21
                            S10 = B11 + B12 
                            P1 = A11 * S1
                            P2 = S2 * B22
                            P3 = S3 * B11
                            P4 = A22 * S4
                            P5 = S5 * S6
                            P6 = S7 * S8
                            P7 = S9 * S10
                            C11 = P5 + P4 - P2 + P6
                            C12 = P1 + P2
                            C21 = P3 + P4
                            C22 = P5 + P1 - P3 - P7

​ 其中A11，A12，A21，A22和B11，B12，B21，B22分别为两个乘数A和B矩阵的四个子矩阵。C11，C12，C21，C22为最终的结果C矩阵的四个子矩阵。该递推式是被数学家证明过的。

​ 该算法的效率为O( n(log27) ),但是相对来说额外空间的使用也是很多的。

Matrix* Matrix::strassen_calc(const Matrix& x)
{
    if (x.row < 2)
    {
        return this->force_calc(x);
    }

    //将第一个矩阵分解为四个子矩阵
    Matrix A11(0, 0, row / 2, col / 2, *this);
    Matrix A12(row / 2, 0, row, col / 2, *this);
    Matrix A21(0, col / 2, row / 2, col, *this);
    Matrix A22(row / 2, col / 2, row, col, *this);
    //将第二个矩阵分解为四个子矩阵
    Matrix B11(0, 0, row / 2, col / 2, x);
    Matrix B12(row / 2, 0, row, col / 2, x);
    Matrix B21(0, col / 2, row / 2, col, x);
    Matrix B22(row / 2, col / 2, row, col, x);

    Matrix* S1 = B12 - B22;
    Matrix* S2 = A11 + A12;
    Matrix* S3 = A21 + A22;
    Matrix* S4 = B21 - B11;
    Matrix* S5 = A11 + A22;
    Matrix* S6 = B11 + B22;
    Matrix* S7 = A12 - A22;
    Matrix* S8 = B21 + B22;
    Matrix* S9 = A11 - A21;
    Matrix* S10 = B11 + B12;

    Matrix* P1 = B12 - B22;
    Matrix* P2 = B12 - B22;
    Matrix* P3 = B12 - B22;
    Matrix* P4 = B12 - B22;
    Matrix* P5 = B12 - B22;
    Matrix* P6 = B12 - B22;
    Matrix* P7 = B12 - B22;

    P1 = A11.strassen_calc(*S1);
    P2 = S2->strassen_calc(B22);
    P3 = S3->strassen_calc(B11);
    P4 = A22.strassen_calc(*S4);
    P5 = S5->strassen_calc(*S6);
    P6 = S7->strassen_calc(*S8);
    P7 = S9->strassen_calc(*S10);

    Matrix *C11 = Matrix::sub(Matrix::add(P5, P4), Matrix::sub(P2, P6));
    Matrix *C12 = Matrix::add(P1, P2);
    Matrix *C21 = Matrix::add(P3, P4);
    Matrix *C22 = Matrix::sub(Matrix::add(P5, P1), Matrix::add(P3, P7));

    return Matrix::merge(C11,C12,C21,C22);
}

执行效果：

这里写图片描述

完整的代码

//Matrix.h
#pragma once
#ifndef _MATRIX_H_
#define _MATRIX_H_

#include <iostream>
#include <vector>
using std::vector;
#define VISE 5
#define GATE 16                 //用来限定使用哪种算法进行计算

#include <cstdlib>
#include <ctime>

typedef int type;
class Matrix
{
private:
    int row;                            //行
    int col;                            //列
    vector<vector<type>> data;          //数据
public:
    Matrix(int row, int col) :data(row),row(row),col(col)                   //矩阵数据生成利用随机数进行生成
    {
        for (int i = 0; i < row; i++)
        {
            data[i].resize(col);
        }

        srand(time(0));
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                data[i][j] = rand() % VISE;
            }
        }
    }

    Matrix(int row1, int col1, int row2, int col2, const Matrix& x) :row(row2 - row1), col(col2 - col1),data(row)
    {
        for (int i = 0; i < row; i++)
        {
            data[i].resize(col);
        }

        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                data[i][j] = x.getElem(col1 + i, row1 + j);
            }
        }
    }

    Matrix(const Matrix& x)
    {
        *this = x;
    }

    //相关算数运算操作
    Matrix* operator+(const Matrix&);
    Matrix* operator-(const Matrix&);
    Matrix* operator*(const Matrix&);
    static Matrix* add(const Matrix*, const Matrix*);                               //+
    static Matrix* sub(const Matrix*, const Matrix*);                               //-
    static Matrix* merge(const Matrix*, const Matrix*,const Matrix*,const Matrix*); //将四个子矩阵合并为一个矩阵
    //获取矩阵的相关元素
    vector<type> operator[](const int);             //取得row
    type getElem(const int,const int) const;        //获取相关节点的数据
    void setElem(const int, const int, type);       //设置节点的数据   

    //计算乘法的算法
    Matrix* force_calc(const Matrix&);              //直接暴力求解
    Matrix* merge_calc(const Matrix&);              //分治求解
    Matrix* strassen_calc(const Matrix&);           //Strassen算法

    void show();                                    //打印矩阵
    bool isSimilar(const Matrix& x);                //行列相同即为同类型矩阵
    void clear(type);                               //设置矩阵中所有的元素为同一个指定的值                                

    ~Matrix();
};

#endif
//_MATRIX_H_
//Matrix.cpp
#include "Matrix.h"

Matrix* Matrix::operator*(const Matrix& x)
{
    if (x.row != this->col)
    {
        return nullptr;
    }

    if (x.row < VISE && x.col < VISE && row < VISE && col < VISE)
    {
        return this->merge_calc(x);
    }

    return this->strassen_calc(x);
}

/**
 *  方法一：暴力直接求解问题
 *  时间复杂度为O(n^3)
 */
Matrix* Matrix::force_calc(const Matrix& x)
{
    if (x.row != this->col)                                             //行列不同无法进行乘法，可以进行补零将相关矩阵填充为可使用的矩阵
    {                                                                   //这里不进行相关的编写
        return nullptr;
    }

    Matrix *ptr = new Matrix(row, x.col);
    ptr->clear(0);
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < x.col; j++)
        {
            for (int k = 0; k < col; k++)
            {
                ptr->setElem(i, j, ptr->getElem(i, j) + getElem(i, k) * x.getElem(k, j));
            }
        }
    }

    return ptr;
}

void Matrix::clear(type cur = 0)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            data[i][j] = cur;
        }
    }
}

/**
 *  方法二：利用分治思想进行求解
 *  存在问题无法解决不同类型的矩阵的问题，要求矩阵的行列必须为2的n次方，若不符合要求可以使用
 *  补0来构造相关的矩阵
 */
Matrix* Matrix::merge_calc(const Matrix& x)
{
    if (x.row == 1)             //当前的矩阵为单个的元素
    {
        Matrix *ptr = new Matrix(x.row, x.col);
        ptr->clear((this->getElem(0, 0))*(x.getElem(0, 0)));
        return ptr;
    }

    //将第一个矩阵分解为四个子矩阵
    Matrix A11(0,0,row/2,col/2,*this);
    Matrix A12(row / 2, 0, row, col / 2, *this);
    Matrix A21(0, col / 2, row / 2, col, *this);
    Matrix A22(row / 2, col / 2, row, col, *this);
    //将第二个矩阵分解为四个子矩阵
    Matrix B11(0, 0, row / 2, col / 2, x);
    Matrix B12(row / 2, 0, row, col / 2, x);
    Matrix B21(0, col / 2, row / 2, col, x);
    Matrix B22(row / 2, col / 2, row, col, x);

    Matrix *C11 = Matrix::add(A11.merge_calc(B11), A12.merge_calc(B21));
    Matrix *C12 = Matrix::add(A11.merge_calc(B12), A12.merge_calc(B22));
    Matrix *C21 = Matrix::add(A21.merge_calc(B11), A22.merge_calc(B21));
    Matrix *C22 = Matrix::add(A21.merge_calc(B12), A22.merge_calc(B22));

    //将C11，C12，C21，C22合并为一个完整的矩阵
    Matrix* ptr = Matrix::merge(C11, C12, C21, C22);

    return ptr;
}

Matrix* Matrix::strassen_calc(const Matrix& x)
{
    if (x.row < 2)
    {
        return this->force_calc(x);
    }

    //将第一个矩阵分解为四个子矩阵
    Matrix A11(0, 0, row / 2, col / 2, *this);
    Matrix A12(row / 2, 0, row, col / 2, *this);
    Matrix A21(0, col / 2, row / 2, col, *this);
    Matrix A22(row / 2, col / 2, row, col, *this);
    //将第二个矩阵分解为四个子矩阵
    Matrix B11(0, 0, row / 2, col / 2, x);
    Matrix B12(row / 2, 0, row, col / 2, x);
    Matrix B21(0, col / 2, row / 2, col, x);
    Matrix B22(row / 2, col / 2, row, col, x);

    Matrix* S1 = B12 - B22;
    Matrix* S2 = A11 + A12;
    Matrix* S3 = A21 + A22;
    Matrix* S4 = B21 - B11;
    Matrix* S5 = A11 + A22;
    Matrix* S6 = B11 + B22;
    Matrix* S7 = A12 - A22;
    Matrix* S8 = B21 + B22;
    Matrix* S9 = A11 - A21;
    Matrix* S10 = B11 + B12;

    Matrix* P1 = B12 - B22;
    Matrix* P2 = B12 - B22;
    Matrix* P3 = B12 - B22;
    Matrix* P4 = B12 - B22;
    Matrix* P5 = B12 - B22;
    Matrix* P6 = B12 - B22;
    Matrix* P7 = B12 - B22;

    P1 = A11.strassen_calc(*S1);
    P2 = S2->strassen_calc(B22);
    P3 = S3->strassen_calc(B11);
    P4 = A22.strassen_calc(*S4);
    P5 = S5->strassen_calc(*S6);
    P6 = S7->strassen_calc(*S8);
    P7 = S9->strassen_calc(*S10);

    Matrix *C11 = Matrix::sub(Matrix::add(P5, P4), Matrix::sub(P2, P6));
    Matrix *C12 = Matrix::add(P1, P2);
    Matrix *C21 = Matrix::add(P3, P4);
    Matrix *C22 = Matrix::sub(Matrix::add(P5, P1), Matrix::add(P3, P7));

    return Matrix::merge(C11,C12,C21,C22);
}

/**
 *  将四个子矩阵合并为一个完整的矩阵
 *  也可以使用分治思想进行解决，以后可能会添加相关的功能
 */
Matrix* Matrix::merge(const Matrix* p1, const Matrix* p2,const Matrix* p3, const Matrix* p4)
{
    //不符合可以进行合并的条件
    if (!(p1->row == p2->row && p2->col == p4->col && p4->row == p3->row && p1->col == p3->col))
    {
        return nullptr;
    }

    Matrix* ptr = new Matrix(p1->row + p3->row, p2->col + p1->col);
    ptr->clear(0);
    //重新装值
    for (int i = 0; i < p1->row; i++)
    {
        for (int j = 0; j < p1->col; j++)
        {
            ptr->setElem(i, j, p1->getElem(i, j));
        }
    }

    for (int i = 0; i < p2->row; i++)
    {
        for (int j = 0; j < p2->col; j++)
        {
            ptr->setElem(i, j + p1->col, p2->getElem(i, j));
        }
    }

    for (int i = 0; i < p3->row; i++)
    {
        for (int j = 0; j < p3->col; j++)
        {
            ptr->setElem(i + p1->row, j, p3->getElem(i, j));
        }
    }

    for (int i = 0; i < p4->row; i++)
    {
        for (int j = 0; j < p4->col; j++)
        {
            ptr->setElem(p1->row + i, p1->col + j, p4->getElem(i, j));
        }
    }

    return ptr;
}

Matrix* Matrix::sub(const Matrix* p1, const Matrix* p2)
{
    if (!(p1->col == p2->col && p1->row == p2->row))
    {
        return nullptr;
    }

    Matrix *ptr = new Matrix(p1->row, p1->col);
    for (int i = 0; i < p1->row; i++)
    {
        for (int j = 0; j < p1->col; j++)
        {
            ptr->setElem(i, j, (p1->getElem(i, j) - p2->getElem(i, j)));
        }
    }

    return ptr;
}

Matrix* Matrix::add(const Matrix* p1, const Matrix* p2)
{
    if (!(p1->col == p2->col && p1->row == p2->row))
    {
        return nullptr;
    }

    Matrix *ptr = new Matrix(p1->row, p1->col);
    for (int i = 0; i < p1->row; i++)
    {
        for (int j = 0; j < p1->col; j++)
        {
            ptr->setElem(i, j, (p1->getElem(i, j) + p2->getElem(i, j)));
        }
    }

    return ptr;
}

Matrix* Matrix::operator+(const Matrix& x)
{
    if (!isSimilar(x))
    {
        return nullptr;
    }

    Matrix *ptr = new Matrix(x.row, x.col);                             //内存需要释放
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            ptr->setElem(i, j, this->getElem(i, j) + x.getElem(i, j));
        }
    }

    return ptr;
}

Matrix* Matrix::operator-(const Matrix& x)
{
    if (!isSimilar(x))
    {
        return nullptr;
    }

    Matrix *ptr = new Matrix(x.row, x.col);                             //内存需要释放
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            ptr->setElem(i, j, this->getElem(i, j) - x.getElem(i, j));
        }
    }

    return ptr;
}

vector<type> Matrix::operator[](const int row)
{
    return data[row];
}

type Matrix::getElem(int row, int col)const
{
    return this->data[row][col];
}

void Matrix::setElem(int row, int col, type cur)
{
    this->data[row][col] = cur;
}

void Matrix::show()
{
    for (int i = 0; i < row; i++)
    {
        if (i == 0)
        {
            std::cout << "┏";
        }
        else if (i == row - 1)
        {
            std::cout << "┗";
        }
        else
        {
            std::cout << "┃";
        }

        for (int j = 0; j < col; j++)
        {
            std::cout.width(4);
            std::cout << data[i][j];
        }

        if (i == 0)
        {
            std::cout << "   ┓";
        }
        else if (i == row - 1)
        {
            std::cout << "   ┛";
        }
        else
        {
            std::cout << "   ┃";
        }

        std::cout << std::endl;
    }
}

bool Matrix::isSimilar(const Matrix& x)
{
    return x.row == this->row && this->col == x.col;
}

Matrix::~Matrix()
{
    this->row = 0;
    this->col = 0;
}

​

落樱弥城
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
strassen-cuda:Strassen矩阵乘法算法的CUDA实现
05-26
Strassen矩阵乘法算法的CUDA实现。
Strassen：一种高效的矩阵相乘算法
weixin_40982849的博客
11-15 2844
Q1：如何提高矩阵相乘效率？ 矩阵乘法是种极其耗时的运算。 以C = A • B为例，其中A和B都是 n x n 的方阵。根据矩阵乘法的定义，计算过程如下： A1: 简单分治法 前提：假定A,B都是n等于2的次幂的方阵 基本思路：计算C=A*B时，将C,A,B矩阵进行分块操作，对每个分块的矩阵进行乘法运 算，运算完毕后重新对得到的C11,C12,C21,C22进行组合操作。 确定递归终止条件：当分块矩阵得到的阶数为1 时，得到的C即是A和B中两个元素的乘积。 每个公式需要计算两次矩阵乘法和一次矩阵加法，
矩阵相乘详解
热门推荐
wmy0217_的博客
02-17 20万+
首先要知道矩阵是怎么相乘的 首先，两个矩阵要是想相乘需要满足，第一个矩阵的列数等于第二个矩阵的行数 满足的话就可以相乘得到新的矩阵了 举个例子嗷： 矩阵a： 1 2 3 3 2 2 2 1 2 矩阵b： 2 2 3 1 2 1 a矩阵是3 * 3（3行3列）的矩阵，b矩阵是3 * 2（3行2列）的矩阵，满足第一个矩阵的列数等于第二个矩阵的行数。那我们就可以相乘了 一个m*n的矩阵和一个...
【算法导论】strassen算法：比较快的矩阵乘法算法
grefwfdxz
08-07 2035
【算法导论】strassen算法：比较快的矩阵乘法算法 标签（空格分隔）：【算法导论】 考虑两个 n 级矩阵 A, B, 矩阵 C = A * B. 则有cij=∑k=1naij∗bkjc_{ij} = \sum_{k=1} ^n a_{ij}*b_{kj}cij​=∑k=1n​aij​∗bkj​. 对于两个矩阵相乘的问题，我们给出三个解决办法：迭代算法、简单分治算法、strassen分治算法。...
矩阵篇（三）-- 矩阵的普通乘积、Hadamard 积、Kronecker 积及其性质
CarpeDiem
10-30 4万+
矩阵乘积分为三种，普通乘积、Hadamard 积、Kronecker 积，常用的是普通乘积（matmul product）和哈达玛积（Hadamard product），这里介绍他们的定义和如何计算，同时用Python实现，详细的性质可以在使用的时候进行查阅。......
问题 P: C语言：数组10(矩阵相乘)
m0_51374762的博客
05-06 1008
题目描述 编写程序，求n×m和m×k矩阵之积。 输入 只有1组数据。 第1行是2个整数n和m(1<n，m<10)，然后连续n行为n×m的矩阵。 第n+2行是2个整数m和k(1<m，k<10)，然后连续m行为m×k的矩阵。 输出 2个矩阵的乘积。 样例输入 Copy 2 3 1 2 3 4 5 6 3 2 1 2 3 4 5 6 样例输出 Copy 22 28 49 64 # include <stdlib.h> # include <stdio.h> int
【线性代数】矩阵的三种相乘方式
小白兔的窝
07-24 3万+
普通乘积 矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义[1]  。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。由于它把许多数据紧凑的集中到了一起，所以有时候可以简便地表示一些复杂的模型。 设A为    的矩阵，B为    的矩阵，那么称  
《实用python程序设计》:矩阵乘法
dong52089的博客
12-26 832
描述 计算两个矩阵的乘法。n*m阶的矩阵A乘以m*k阶的矩阵B得到的矩阵C 是n*k阶的，且C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + …… +A[i][m-1]*B[m-1][j](C[i][j]表示C矩阵中第i行第j列元素)。 输入 第一行为n, m, k，表示A矩阵是n行m列，B矩阵是m行k列，n, m, k均小于100 然后先后输入A和B两个矩阵，A矩阵n行m列，B矩阵m行k列，矩阵中每个元素的绝对值不会大于1000。 输出 输出矩阵C，一共
c语言计算一个m×n矩阵a和一个n×k矩阵b的乘积,第十五章 动态规划——矩阵链乘法...
weixin_42608299的博客
05-21 1106
#include#includeusing namespacestd;#define A_ROWS 3#define A_COLUMNS 2#define B_ROWS 2#define B_COLUMNS 3void matrix_multiply(int A[A_ROWS][A_COLUMNS],int B[B_ROWS][B_COLUMNS],in...
几个结构矩阵乘积的Strassen算法
06-08
几个结构矩阵乘积的Strassen算法，矩阵乘法相关论文。
strassen_矩阵乘法的strassen算法_
10-02
矩阵乘法的strassen算法，随机产生nxn阶方阵并做乘法，n为2的幂，结果打印输出
java实现任意矩阵Strassen算法
09-02
主要介绍了java实现任意矩阵Strassen算法的相关资料,需要的朋友可以参考下
strassen矩阵乘法的测试数据
最新发布
01-28
本文件包含两个512*512大小的矩阵la.txt和lb.txt，可用于作为算法导论中strassen矩阵乘法的测试数据。完整代码详见文章https://blog.csdn.net/baidu_40395808/article/details/135890112。
矩阵乘法的 strassen 算法的 rust 语言实现，时间复杂度 O(n^2.81)
08-31
使用 rust 实现的矩阵乘法算法，包括矩阵乘法定义的直接相乘算法，时间复杂度 O(n^3)，简单的分治算法（将矩阵划分为 4 个子矩阵），时间复杂度 O(n^3)，以及strassen算法（使用了10个中间矩阵存储中间运算结果），...
Python编程练习：矩阵乘法
了哈哈的博客
08-22 2826
描述 计算两个矩阵的乘法。n*m阶的矩阵A乘以m*k阶的矩阵B得到的矩阵C 是n*k阶的，且C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + …… +A[i][m-1]*B[m-1][j](C[i][j]表示C矩阵中第i行第j列元素)。 输入 第一行为n, m, k，表示A矩阵是n行m列，B矩阵是m行k列，n, m, k均小于100 然后先后输入A和B两个矩阵，A矩阵n行m列，B矩阵m行k列，矩阵中每个元素的绝对值不会大于1000。 输出 输出矩阵C，一共
矩阵与矩阵乘积简介
小白学视觉
11-15 1582
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达【导读】向量是存储和操作数据的一种有用的方法。可以用箭头或数字数组来表示它们。然而，创建更复杂的数据结构是有帮助的，而...
矩阵的各种乘积
zkq_1986的博客
10-11 4万+
操作 数学符号 举例 说明 点积(dot product)，也称内积(inner product)，标量积（scalar product） A.B           1.向量点积。变成一个数。 2.矩阵点积。矩阵的点积是每行每列的点积的矩阵。 外积(outer product)
5.3矩阵乘积(三元组存储结构)
IT1995的博客
02-10 1万+
5.3矩阵乘积(三元组存储结构)
矩阵乘法的简单理解
Blogs of zcy1221
01-19 790
关于矩阵的乘法，学过线性代数的同学应该都知道，而且都会算. 但矩阵乘法究竟该怎么理解？不妨看看我的回答！
矩阵乘法代码strassen
03-11
Strassen算法是一种用于矩阵乘法的分治算法，它可以在较短的时间内计算出两个矩阵的乘积。该算法的时间复杂度为O(n^log7)，比传统的矩阵乘法算法更快。Strassen算法的实现需要一定的数学基础和编程技巧，可以在网上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值