矩阵乘法的三个版本实现

最新推荐文章于 2022-04-19 10:26:06 发布
最新推荐文章于 2022-04-19 10:26:06 发布
阅读量453 收藏 1
点赞数 1
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanjianchuan/article/details/43925449
版权

version1

#include<stdio.h>
//Matrix multiplication O(n^3) 按照定义算
const int N=200;
void Multiply(int A[][N],int B[][N],int C[][N],int n)
{//C=A*B
    int i,j,k;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++){
            C[i][j]=0;
            for(k=0;k<n;k++) C[i][j]+=A[i][k]*B[k][j];
        }
}
int main(void)
{
    //freopen("1.txt","r",stdin);
    //freopen("2.txt","w",stdout);
    int A[N][N],B[N][N],C[N][N],n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(A+i)+j);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(B+i)+j);
    Multiply(A,B,C,n);//计算C=A*B
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++)
            printf("%d ",C[i][j]);
        putchar('\n');
    }
    return 0;
}


version2

#include<stdio.h>
//Matrix multiplication O(n^3) T(n)=8T(n/2)+O(n^2)
//虽然时间复杂度仍旧一样，但是其思想为strassen算法作铺垫
const int N=200;
void Add(int A[][N],int B[][N],int C[][N],int n)
{//C=A+B
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            C[i][j]=A[i][j]+B[i][j];
}

void Multiply(int A[][N],int B[][N],int C[][N],int n)
{//C=A*B
    if(n==1) C[0][0]=A[0][0]*B[0][0];
    else{
        int halfn=n/2,i,j;
        int A11[halfn][N],A12[halfn][N],A21[halfn][N],A22[halfn][N];//其实N应该是halfn,但考虑到函数参数传递，二维数组第二维要对应
        int B11[halfn][N],B12[halfn][N],B21[halfn][N],B22[halfn][N];
        //A、B分解成4个小矩阵
        for(i=0;i<halfn;i++)
            for(j=0;j<halfn;j++){
                A11[i][j]=A[i][j];A12[i][j]=A[i][j+halfn];
                A21[i][j]=A[i+halfn][j];A22[i][j]=A[i+halfn][j+halfn];
                B11[i][j]=B[i][j];B12[i][j]=B[i][j+halfn];
                B21[i][j]=B[i+halfn][j];B22[i][j]=B[i+halfn][j+halfn];
            }

        //递归计算8次矩阵乘法，同时做加法
        int temp1[halfn][N],temp2[halfn][N];
        Multiply(A11,B11,temp1,halfn);
        Multiply(A12,B21,temp2,halfn);
        int C11[halfn][N];
        Add(temp1,temp2,C11,halfn);

        Multiply(A11,B12,temp1,halfn);
        Multiply(A12,B22,temp2,halfn);
        int C12[halfn][N];
        Add(temp1,temp2,C12,halfn);

        Multiply(A21,B11,temp1,halfn);
        Multiply(A22,B21,temp2,halfn);
        int C21[halfn][N];
        Add(temp1,temp2,C21,halfn);

        Multiply(A21,B12,temp1,halfn);
        Multiply(A22,B22,temp2,halfn);
        int C22[halfn][N];
        Add(temp1,temp2,C22,halfn);

        //将C11,C12,C21,C22合并起来
        for(i=0;i<halfn;i++)
            for(j=0;j<halfn;j++){
                C[i][j]=C11[i][j];C[i][j+halfn]=C12[i][j];
                C[i+halfn][j]=C21[i][j];C[i+halfn][j+halfn]=C22[i][j];
            }
    }
}
int main(void)
{
    //freopen("1.txt","r",stdin);
    //freopen("2.txt","w",stdout);
    int A[N][N],B[N][N],C[N][N],n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(A+i)+j);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(B+i)+j);

    Multiply(A,B,C,n);//计算C=A*B

    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++)
            printf("%d ",C[i][j]);
        putchar('\n');
    }
    return 0;
}

version3  strassen算法。书上说，可以用下标运算来增加速度，还可以大量减少空间使用，不过我暂时没想到。 

#include<stdio.h>
//Matrix multiplication O(n^lg7)
const int N=200;//n=128时，就stackoverflow了。所以都感觉不到n^lg7与n^3的区别了
void Add(int A[][N],int B[][N],int C[][N],int n)
{//C=A+B
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            C[i][j]=A[i][j]+B[i][j];
}
void Add1(int A[][N],int B[][N],int C[][N],int D[][N],int E[][N],int n)
{//E=A+B-C+D
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            E[i][j]=A[i][j]+B[i][j]-C[i][j]+D[i][j];
}
void Add2(int A[][N],int B[][N],int C[][N],int D[][N],int E[][N],int n)
{//E=A+B-C-D
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            E[i][j]=A[i][j]+B[i][j]-C[i][j]-D[i][j];
}
void Minus(int A[][N],int B[][N],int C[][N],int n)
{//C=A-B
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            C[i][j]=A[i][j]-B[i][j];
}

void Multiply(int A[][N],int B[][N],int C[][N],int n)
{//C=A*B
    if(n==1) C[0][0]=A[0][0]*B[0][0];
    else{
        int halfn=n/2,i,j;
        int A11[halfn][N],A12[halfn][N],A21[halfn][N],A22[halfn][N];//其实N应该是halfn,但考虑到函数参数传递，二维数组第二维要对应
        int B11[halfn][N],B12[halfn][N],B21[halfn][N],B22[halfn][N];
        //A、B分解成4个小矩阵
        for(i=0;i<halfn;i++)
            for(j=0;j<halfn;j++){
                A11[i][j]=A[i][j];A12[i][j]=A[i][j+halfn];
                A21[i][j]=A[i+halfn][j];A22[i][j]=A[i+halfn][j+halfn];
                B11[i][j]=B[i][j];B12[i][j]=B[i][j+halfn];
                B21[i][j]=B[i+halfn][j];B22[i][j]=B[i+halfn][j+halfn];
            }

        //10次加减法
        int S1[halfn][N],S2[halfn][N],S3[halfn][N],S4[halfn][N],S5[halfn][N],S6[halfn][N],S7[halfn][N],S8[halfn][N],S9[halfn][N],S10[halfn][N];
        Minus(B12,B22,S1,halfn);//S1=B12-B22
        Add(A11,A12,S2,halfn);//S2=A11+A12
        Add(A21,A22,S3,halfn);//S3=A21+A22
        Minus(B21,B11,S4,halfn);//S4=B21-B11
        Add(A11,A22,S5,halfn);//S5=A11+A22
        Add(B11,B22,S6,halfn);//S6=B11+B22
        Minus(A12,A22,S7,halfn);//S7=A12-A22
        Add(B21,B22,S8,halfn);//S8=B21+B22
        Minus(A11,A21,S9,halfn);//S9=A11-A21
        Add(B11,B12,S10,halfn);//S10=B11+B12

        //递归计算7次矩阵乘法
        int P1[halfn][N],P2[halfn][N],P3[halfn][N],P4[halfn][N],P5[halfn][N],P6[halfn][N],P7[halfn][N];
        Multiply(A11,S1,P1,halfn);//P1=A11*S1
        Multiply(S2,B22,P2,halfn);//P2=S2*B22
        Multiply(S3,B11,P3,halfn);//P3=S3*B11
        Multiply(A22,S4,P4,halfn);//P4=A22*S4
        Multiply(S5,S6,P5,halfn);//P5=S5*S6
        Multiply(S7,S8,P6,halfn);//P6=S7*S8
        Multiply(S9,S10,P7,halfn);//P7=S9*S10

        int C11[halfn][N],C12[halfn][N],C21[halfn][N],C22[halfn][N];
        Add1(P5,P4,P2,P6,C11,halfn);//C11=P5+P4-P2+P6
        Add(P1,P2,C12,halfn);//C12=P1+P2
        Add(P3,P4,C21,halfn);//C21=P3+P4
        Add2(P5,P1,P3,P7,C22,halfn);//C22=P5+P1-P3-P7

        //将C11,C12,C21,C22合并起来
        for(i=0;i<halfn;i++)
            for(j=0;j<halfn;j++){
                C[i][j]=C11[i][j];C[i][j+halfn]=C12[i][j];
                C[i+halfn][j]=C21[i][j];C[i+halfn][j+halfn]=C22[i][j];
            }
    }
}
int main(void)
{
    //freopen("1.txt","r",stdin);
    //freopen("2.txt","w",stdout);
    int A[N][N],B[N][N],C[N][N],n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(A+i)+j);
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%d",*(B+i)+j);

    Multiply(A,B,C,n);//计算C=A*B

    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++)
            printf("%d ",C[i][j]);
        putchar('\n');
    }
    return 0;
}


yuanjianchuan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三个元素的矩阵乘除法
光头迪迦
01-02 3191
 百度定义为： 总结一下就是，如果A和B两个矩阵要相乘，A的列数要和B的行数相同的，其实矩阵就是线性代数中对多项式常量的一种抽象表达。 比如：A是2 * 80的矩阵，B是80*2的矩阵，得出的还是2*2的矩阵，简单说就是结果是A的行*B的列的矩阵，哪怕A的列是10000呢，B的行是10000，都不影响A*B的行列数，A的列只能等于B的行，否则就无法相乘。 所谓矩阵链乘法就是：A*B*C*D...
从矩阵乘法的不同计算方式来看局部性原理
haolexiao的专栏
03-28 2750
今天碰到的关于矩阵乘法不同情况下运算速度的问题，隐约记得是因为缓存的问题，后来突然想起来CSAPP那本书上讲过这个东西的，就是通过矩阵乘法三重循环的不同顺序来讲的局部性原理的，所以翻过来又看了一下。 两个矩阵A,B相乘得到C【为了方便起见，把它们都看成n*n的方阵】经典的做法就是用三重循环来实现，但是具体这三重循环如何进行排列，就非常的有讲究。 假设n是一个非常大的数,也就意味着如果跨行的话,必然
矩阵乘法串行并行算法
12-19
512*512的矩阵，实现并行算法分行，分列，分块的做法以及串行算法的实现
高性能计算实验——通用矩阵乘法串行编程的实现及优化
weixin_43973089的博客
04-19 3383
高性能计算实验——通用矩阵乘法串行编程的实现及优化1.实验目的1.1通用矩阵乘法1.2通用矩阵乘法优化1.3大规模矩阵计算优化2.实验过程和核心代码2.1通用矩阵乘法2.2通用矩阵乘法优化2.3大规模矩阵计算优化4.实验结果4.1通用矩阵乘法4.2Strassen算法5.实验感想 1.实验目的 1.1通用矩阵乘法 熟练掌握通用矩阵乘法的原理以及实现GEMM，为后续实验打下基础，用C 语言实现一个矩阵乘法。 1.2通用矩阵乘法优化 进一步熟悉矩阵乘法的实现，深入学习矩阵乘法的优化算法，学习矩阵乘法的复杂度分析
学习笔记：几种矩阵乘法（matmul product普通乘积、hadamard product矩阵点乘、kronecker product克罗内克积、斯特拉森矩阵乘法）
热门推荐
与贰的博客
07-08 3万+
1、普通矩阵乘法（matmul product）假设矩阵A大小是M*N，矩阵B大小是N*P，C=AB这里选取一个例子这里的矩阵乘法要求相乘的两个矩阵一个的行数得等于另一个的列数，否则，无法进行乘机运算。2、矩阵点乘（hadamard product）矩阵点乘，英文hadamard product，因此又称哈达码积。要求相乘的两个矩阵A和B大小完全相同，即A，B大小都为M*N，然后。下面举一个运算实...
Java实现的矩阵乘法示例
08-26
Java实现的矩阵乘法示例 矩阵乘法是线性代数中的一种基本操作，它将两个矩阵相乘，得到一个新的矩阵。在Java中，矩阵乘法可以通过循环遍历和数组操作来实现。下面是Java实现的矩阵乘法示例的知识点总结： 一、矩阵...
汇编语言实现矩阵乘法
10-30
矩阵乘法的实现可以分为三个部分：数据输入、矩阵乘法运算、结果输出。在数据输入部分，用户可以从键盘输入矩阵数据，程序会检查输入数据是否在指定范围内，如果不在范围内，程序会提示用户重新输入。在矩阵乘法运算...
C中实现矩阵乘法的一种高效的方法
09-05
在优化后的矩阵乘法实现中，由于连续访问了矩阵B的列，以及连续读取矩阵A的元素，我们有效地利用了这两个特性，减少了访问内存的次数，从而提高了执行速度。 在现代处理器中，访问L1缓存可能只需要几个时钟周期，L2...
基于C++的矩阵乘法计算函数
10-08
//该成员函数能够对这三个矩阵的维数进行判断，若不符合矩阵的乘法则返回错误信息 //由于本程序使用vector向量作为容器存储矩阵，因此改变矩阵的维数只需要更改矩阵本身即可，无需更改维度参数 //本程序输出结果正确...
C++中实现矩阵的加法和乘法实例
08-30
- 在`main()`函数中，我们创建了三个`Matrix`对象`m1`、`m2`和`m3`，并分别调用它们的`display()`方法展示初始矩阵。 - 接着，我们执行矩阵加法`m1.Madd(m2)`，并将结果打印出来。 - 最后，我们进行矩阵乘法`m1....
C语言中矩阵乘法的实现
weixin_42327840的博客
03-17 4679
在这里插入代码片@TOC 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式
快速矩阵乘法的算法实现
qq_42327795的博客
03-10 1万+
快速矩阵乘法
以矩阵乘法为例比较串行和各并行算法运行效率
vincent_nkcs的博客
04-22 6535
1 问题描述   本次实验分别使用串行算法、Cache优化算法、SSE编程和分片策略算法实现了矩阵乘法运算，实验采用同一个样本，即矩阵大小为512个元素，元素值为由时间生成的随机数，每个算法对此样本运行十次，并记录每次运行时间和十次运算的平均运行时间。实验环境：计算机apple macbook pro2015、系统macOS High Sierra10.13.5、编辑器vscode&C/C...
矩阵相乘的两种实现方法
zgh1988的专栏
05-07 3083
第一种最朴素的算法就是用A矩阵的第i行与B矩阵的第j列的各个元素相乘求和，得到C矩阵的第i行第j列的元素。 void MatrixMulMatrix_Solution1(int matrix1[][2], int m, int matrix2[][3], int n, int result[][3]) { int i, j, k; if (matrix1 == NULL || matrix2
分治策略之矩阵乘法的几种实现
爱你的推理能手
10-27 6528
欢迎关注，定期更新算法问题 今天介绍一下分治算法的一个典型例子——矩阵乘法 如果以前了解过矩阵，应该知道矩阵的乘法公式C(m,n)=A(m,k)*B(k,n)，在这里我们只讨论方阵，假设A是n*n阶，B也是n*n阶，那么要计算乘积需要进行n^2个元素，看《算法导论》给出的伪码： 上边这个过程进行三次循环，每次循环执行n步，故花费时间是O(n^3)，下边是代码实现： void
C语言之两矩阵乘法的实现
宇哲
03-26 1万+
首先我们要清楚矩阵乘法实现需要满足的条件， 矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义[1] 。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。//关于任意两个矩阵的乘法运算 //关于任意两个矩阵的乘法运算 #include<stdio.h> #include<stdlib.
【游戏课】技术片段之——三个矩阵相乘的结果
harmony的专栏
04-03 6378
游戏课的老师让我们计算任意3个4*4矩阵ABC的乘积有几种可能的结果，本文对这个问题进行简单的探讨。 猜想：有6种结果。即ABC ACB BCA BAC CAB CBA结果均不相同。 证明： 我们通过研究ABC与其他乘积的相等关系来证明。矩阵满足乘法结合律，不满足交换律，因此A(BC) != A(CB)，即ABC！=ACB。 同理ABC！=BAC，ABC！=BCA，ABC！=CAB。 下
对行列不同的矩阵相乘的做法（主要是对三层for循环中的判断条件选择）
qq_47627886的博客
09-21 3502
import java.util.Random; public class free { public static void main(String[] args) { // TODO Auto-generated method stub Random r = new Random(); int[][] m = new int[3][2];//第一个矩阵 int[][] n = new int[2][4];//第二个矩阵 for (int i = 0; i < m.len.
矩阵加 减 乘法的C语言实现
青釉猫
10-11 1万+
矩阵的加减法：就是对应位置相加减即可 对于满足以下条件的矩阵A，B： 我们有： 加法， 减法，     矩阵的乘法： 对于满足以下条件的矩阵A，B，C： 我们有： 其中：   要注意的是矩阵群没有乘法交换律，也就是说： 下面的代码是输入两个矩阵，输出他们的乘 #include &lt;stdio.h&gt; int main(vo...
c语言实现矩阵乘法的三级循环展开
最新发布
07-12
下面是用 C 语言实现矩阵乘法的三级循环展开的示例代码： ```c #include #define N 4 void matrix_multiply(int A[][N], int B[][N], int C[][N]) { for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值