strassen矩阵相乘算法C++代码

合集下载

strassen算法-现实2次幂,偶数奇数

strassen算法-现实2次幂,偶数奇数
按照分治的思想可以看出要想减少乘法运算次数关键在于计算2个2阶方阵的乘积时能否用少于8次的乘法运算
Strassen算法
姓名: 王军袖 学号: 31609059
1
目录
1
算法思想
2
3
算法代码
运行结果
2
算法思想
分治算法
其核心思想是将大的问题分解成若干小的子问题进行 处理,从而使复杂的问题变得简单。表现在算法中就 是递归算法。
m1 m2 m3 m4 m5 m6 m7 = = = = = = = (a11 + a22) * (b11 + b22); (a21 + a22) * b11; a11 * (b12 - b22); a22 * (b21 - b11); (a11 + a12) * b22; (a21 - a11) * (b11 + b12); (a12 - a22) * (b21 + b22); 再做若干次加、减法: c11 = m1 + m4 - m5 + m7 c12 = m3 + m5 c21 = m2 + m4 c22 = m1 +m3 -m2 + m6
16
Matrix **cr=new Matrix*[n];//初始化cr,储存ar*br结果 //阶为偶数矩阵想乘 for ( i=0;i<n;i++){ Matrix MutiEven(Matrix A,Matrix B){ cr[i]=new Matrix[n]; int n=A.n,m=1; for ( j=0;j<n;j++) int i,j; cr[i][j]=Matrix(m); //将矩阵阶拆分成m*n,n为奇数 } m为2的幂次 for( i=0;i<n;i++)//用传统方法将ar和br相乘,储存在cr中 while(!(n&1)){ for( j=0;j<n;j++) n>>=1; for(int k=0;k<n;k++) m<<=1; cr[i][j]=Plus(cr[i][j],Muti2n(ar[i][k],br[k][j])); Matrix C(m*n);//声明C } for( i=0;i<n;i++)//将cr合并成一个矩阵C //将A拆分为n^2个m阶矩阵,在ar中储存。 for( j=0;j<n;j++) Matrix **ar=new Matrix*[n]; for(int x=0;x<m;x++) for ( i=0;i<n;i++){ for(int y=0;y<m;y++) ar[i]=new Matrix[n]; for ( j=0;j<n;j++) C.m[i*m+x][j*m+y]=cr[i][j].m[x][y]; ar[i][j]=Split(A,i*m,j*m,m); return C;} } Matrix **br=new Matrix*[n];//同A for (i=0;i<n;i++){ br[i]=new Matrix[n]; for ( j=0;j<n;j++) 17 br[i][j]=Split(B,i*m,j*m,m);}

4-2.矩阵乘法的Strassen算法详解

4-2.矩阵乘法的Strassen算法详解

4-2.矩阵乘法的Strassen 算法详解题⽬描述请编程实现矩阵乘法,并考虑当矩阵规模较⼤时的优化⽅法。

思路分析根据wikipedia 上的介绍:两个矩阵的乘法仅当第⼀个矩阵B 的列数和另⼀个矩阵A 的⾏数相等时才能定义。

如A 是m×n 矩阵和B 是n×p 矩阵,它们的乘积AB 是⼀个m×p 矩阵,它的⼀个元素其中 1 ≤ i ≤ m,1 ≤ j ≤ p 。

值得⼀提的是,矩阵乘法满⾜结合律和分配率,但并不满⾜交换律,如下图所⽰的这个例⼦,两个矩阵交换相乘后,结果变了:下⾯咱们来具体解决这个矩阵相乘的问题。

解法⼀、暴⼒解法其实,通过前⾯的分析,我们已经很明显的看出,两个具有相同维数的矩阵相乘,其复杂度为O (n^3),参考代码如下:解法⼆、Strassen 算法在解法⼀中,我们⽤了3个for 循环搞定矩阵乘法,但当两个矩阵的维度变得很⼤时,O (n^3)的时间复杂度将会变得很⼤,于是,我们需要找到⼀种更优的解法。

⼀般说来,当数据量⼀⼤时,我们往往会把⼤的数据分割成⼩的数据,各个分别处理。

遵此思路,如果丢给我们⼀个很⼤的两个矩阵呢,是否可以考虑分治的⽅法循序渐进处理各个⼩矩阵的相乘,因为我们知道⼀个矩阵是可以分成更多⼩的矩阵的。

如下图,当给定⼀个两个⼆维矩阵A B 时:这两个矩阵A B 相乘时,我们发现在相乘的过程中,有8次乘法运算,4次加法运算:矩阵乘法的复杂度主要就是体现在相乘上,⽽多⼀两次的加法并不会让复杂度上升太多。

故此,我们思考,是否可以让矩阵乘法的运算过程中乘法的运算次数减少,从⽽达到降低矩阵乘法的复杂度呢?答案是肯定的。

1969年,德国的⼀位数学家Strassen 证明O (N^3)的解法并不是矩阵乘法的最优算法,他做了⼀系列⼯作使得最终的时间复杂度降低到了O(n^2.80)。

他是怎么做到的呢?还是⽤上⽂A B 两个矩阵相乘的例⼦,他定义了7个变量:如此,Strassen算法的流程如下:;表⾯上看,Strassen 算法仅仅⽐通⽤矩阵相乘算法好⼀点,因为通⽤矩阵相乘算法时间复杂度是,⽽Strassen 算法复杂度只是。

斯特拉森矩阵相乘算法(c语言实现)

斯特拉森矩阵相乘算法(c语言实现)

斯特拉森矩阵相乘算法(c语⾔实现)我们所要介绍的斯特拉森矩阵相乘算法是德国数学家沃尔克·施特拉森 (Volker Strassen) 于1969年提出的,该算法的主要思想是⼀种分治思想,即将⼀个2n的⽅阵分解成4个2n-1的⼩⽅阵。

借助这种办法,任何有穷⽅阵都可以简化为有限个2×2⽅阵,所以今天我们主要介绍斯特拉森算法在2×2⽅阵上的应⽤。

⾸先我们假设有两个2×2矩阵,A,B.A = a11 a12B = b11 b12a21 a22 b21 b22我们设矩阵相乘的结果矩阵为C。

则C = c11 c12c21 c22由斯特拉森算法可得7个⼩矩阵1. m1 = (a12 - a22)(b21 + b22)2. m2 = (a11 + a22)(b11 + b22)3. m3 = (a21-a11)(b11+b12)4. m4 = (a11+a12) * b225. m5 = a11 * (b12 - b22)6. m6 = a22 * (b21 - b11)7. m7 = (a21 + a22) * b11易得1. c11 = m6 + m1 + m2 - m42. c12 = m5 + m43. c21 = m6 + m74. c22 = m5 + m3 + m2 - m7应⽤该种⽅法可将花费的时间由最开始的Ω(n3 )变成了O(n lg7)⼜因为lg7在2.80和2.81之间,所以其运⾏时间为O(n2.81),相⽐⼀开始有较为明显的优化(尤其是在处理较⼤的矩阵时)。

⽰例代码如下:1int a[2][2] = { 2,3,4,5 },2 b[2][2] = { 1,7,2,6 };//输⼊矩阵3int c[2][2];//建⽴结果矩阵4int m1 = (a[0][1] - a[1][1]) * (b[1][0] + b[1][1]),5 m2 = (a[0][0] + a[1][1]) * (b[0][0] + b[1][1]),6 m3 = (a[1][0] - a[0][0]) * (b[0][0] + b[0][1]),7 m4 = (a[0][0] + a[0][1]) * b[1][1],8 m5 = a[0][0] * (b[0][1] - b[1][1]),9 m6 = a[1][1] * (b[1][0] - b[0][0]),10 m7 = (a[1][0] + a[1][1]) * b[0][0];11 c[0][0] = m6 + m2 + m1 - m4;12 c[0][1] = m5 + m4;13 c[1][0] = m6 + m7;14 c[1][1] = m5 + m3 + m2 - m7;。

矩阵乘法的一个新快速算法

矩阵乘法的一个新快速算法

矩阵乘法的一个新快速算法矩阵乘法对于两个矩阵的相乘,只有在第一个矩阵的列数和第二个矩阵的行数相同的时候,其乘积才有意义。

最早出现的就是一般的矩阵乘法,并且在很长的一段时间内人们都认为该算法无法继续改进,直到1969年,Strassen发明了一个算法,首次降低了矩阵乘法的时间复杂度,并且该算法也以他的名字命名——Strassen算法。

在后续的几十年里,人们在Strassen算法的基础上不断改进算法,并且在逐步降低矩阵乘法的时间复杂度。

比较有里程碑意义的是在1990年,Coppersmith和Winograd两个人对算法进行的改进,其算法也被称为算法。

一般矩阵乘法一般矩阵乘法,将第一个矩阵一行中的元素与第二个矩阵中一列对应位置上元素的乘积之和,作为第三个矩阵这一行一列对应位置的结果。

在这里插入图片描述在这里插入图片描述对于n*n的矩阵乘法其时间复杂度为O(n3)/** Generate Algorithm* matA a M*K matrix* matB a K*N matrix* matC a M*N matrix* matC = matA * matBstatic void mm_generate(float* matA, float* matB, float* matC, const int M, const int N, const int K){for (int i = 0; i < M;i++){for (int j = 0; j < N;j++){float sum = 0.0f;for (int k = 0; k < K;k++){sum += matA[i*K + k] * matB[k*N + j];}matC[i*N + j] = sum;}}}123456789101112131416171819202122分块算法将矩阵分割成四块来计算在这里插入图片描述在这里插入图片描述这里需要8个乘法和4个加法其时间复杂度依然是O(n3)Strassen 算法Strassen在分块的基础上进行改进在这里插入图片描述在这里插入图片描述这里用了7个乘法和18个加/减法对于每一个n * n 矩阵,可以看成有 2 * 2 的小矩阵拼接而来,因此会有n/2 * n/2 个小矩阵T(n) = 7 * T(n/2) + O(n2)T(n) = O(nlg7) + O(n2.81)其算法的时间复杂度为O(n2.81)Github:Straseen算法的代码实现相较与一般算法来说,只有在n很大的时候才会体现出性能上的优势,并且在实现是采用递归调用,每次调用会产生中间7个矩阵,所占用的空间要比一般的算法多。

C语言实现矩阵计算

C语言实现矩阵计算

C语言实现矩阵计算C语言是一种广泛使用的编程语言,也是实现矩阵计算的一种常用工具。

在C语言中,我们可以使用数组来表示矩阵,并通过循环结构和算术运算符来实现矩阵计算的各种功能。

首先,我们需要实现矩阵的输入和输出功能。

在C语言中,我们可以使用二维数组来表示矩阵。

下面是一个示例代码,用来输入和显示一个矩阵:```c#include <stdio.h>//定义最大矩阵的大小#define MAX_SIZE 100//函数用于输入一个矩阵void inputMatrix(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols)printf("请输入矩阵元素:\n");for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)scanf("%d", &matrix[i][j]);}}//函数用于显示一个矩阵void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols)printf("矩阵元素为:\n");for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)printf("%d ", matrix[i][j]);}printf("\n");}```上述代码定义了两个函数:`inputMatrix`用于输入一个矩阵,`displayMatrix`用于显示一个矩阵。

我们可以通过调用这两个函数来输入和显示矩阵。

接下来,我们可以实现矩阵的加法、减法和乘法等功能。

以下是一个示例代码,用于实现矩阵的加法:```c//函数用于计算两个矩阵的加法void addMatrix(int matrix1[MAX_SIZE][MAX_SIZE], intmatrix2[MAX_SIZE][MAX_SIZE], int result[MAX_SIZE][MAX_SIZE], int rows, int cols)for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)result[i][j] = matrix1[i][j] + matrix2[i][j];}}```上述代码中,我们定义了一个`addMatrix`函数,该函数接受两个输入矩阵和一个结果矩阵,将两个输入矩阵的对应元素相加,并将结果存储在结果矩阵中。

c语言strassen矩阵乘法代码

c语言strassen矩阵乘法代码

c语言strassen矩阵乘法代码Strassen矩阵乘法是一种高效的矩阵乘法算法,它通过将原始矩阵分解为较小的子矩阵,并使用递归的方法进行计算,从而减少了乘法运算的次数,提高了算法的效率。

在传统的矩阵乘法算法中,对于一个n×n的矩阵,需要进行n^3次乘法和n^2次加法运算。

而Strassen算法通过将矩阵分解为4个n/2×n/2的子矩阵,并使用一系列的加法和减法来计算乘积,从而减少了乘法运算的次数。

具体而言,Strassen算法的实现过程如下:1. 将输入矩阵A和B分别分解为4个n/2×n/2的子矩阵:A = | A11 A12 |B = | B11 B12 || | | || A21 A22 | | B21 B22 |2. 计算7个子矩阵的乘积:P1 = A11 * (B12 - B22)P2 = (A11 + A12) * B22P3 = (A21 + A22) * B11P4 = A22 * (B21 - B11)P5 = (A11 + A22) * (B11 + B22)P6 = (A12 - A22) * (B21 + B22)P7 = (A11 - A21) * (B11 + B12)3. 计算结果矩阵C的四个子矩阵:C11 = P5 + P4 - P2 + P6C12 = P1 + P2C21 = P3 + P4C22 = P5 + P1 - P3 - P74. 将四个子矩阵合并为结果矩阵C:C = | C11 C12 || || C21 C22 |通过上述步骤,可以得到矩阵乘法的结果。

需要注意的是,为了使Strassen算法能够适用于任意大小的矩阵,需要对矩阵的维度进行调整,使其为2的幂次方。

Strassen算法的时间复杂度为O(n^log2(7)),相比传统的矩阵乘法算法O(n^3)要小。

然而,由于Strassen算法中涉及到递归调用和大量的矩阵拆分和合并操作,其常数系数较大,因此在实际应用中,并不一定比传统的矩阵乘法算法更快。

Strassen算法

Strassen算法

问题分析
一般的矩阵乘法:
c[i, j ] k 1 a[i, k ] * b[k , j ]
k n
For i=1 to n do for j=1 to n do c[i,j]=0 for k=1 to n do c[i,j]=c[i,j]+a[i,k]*b[k,j] 一般算法: T(n)=n3 stressen算法:T(n)=n3*log7
函数实现
主函数调用下面六个函数可以实现2的N次幂阶数的矩阵相乘 : int judgement(int n) /*判断用户输入的矩阵的阶数是 否为2的N次方*/ void divide(int *d,int *d11,int *d12,int *d21,int *d22,int n) /*分割矩阵*/ int *merge(int *d11,int *d12,int *d21,int *d22,int n) /*合并矩阵*/ int *minus(int *a,int *b,int n) /*两个矩阵相减*/ int *plus(int *a,int *b,int n) /*两个矩阵相加*/ int *strassen(int *a,int *b,int n) /*strassen算法 */
Strassen算法
学生:解思南 专业:计算机技术 LOGO 学号:31209027

算法回顾
1、用擅长的语言编程实现Strassen算法,并 进行演示。 2、Strassen要求阶n是2的幂,但这样的情况 很少。对任一偶数n,总有 n=m*2k, 将矩阵 分为m*m个的2k阶矩阵。小矩阵用Strassen相 乘,大矩阵用传统算法。设计出偶数阶矩阵相 乘的算法。 3、进一步:对任意的正整数n,如何求n阶矩 阵相乘?

矩阵连乘和strassen矩阵乘法

矩阵连乘和strassen矩阵乘法

矩阵连乘和strassen矩阵乘法矩阵连乘问题和 Strassen 矩阵乘法是计算机科学中的两个重要问题。

矩阵常常被用来表示线性算法问题,而矩阵的乘法则是表示两个矩阵之间运算的一种方法。

本文将对这两个问题分别进行介绍,以便更深入地了解矩阵的应用和计算方法。

矩阵连乘问题矩阵连乘问题是指给定一组矩阵,求其乘积的最小计算次数,并构造出相应的计算方法。

在算法中,我们通常采用递归的思想来解决这个问题。

递归过程中,我们根据矩阵的大小将矩阵划分成更小的子矩阵,然后再对这些子矩阵进行计算。

设矩阵连乘的矩阵序列为 A1, A2, A3, ..., An,其中矩阵 Ai 的行数和列数分别为 pi - 1 和 pi。

那么,计算这个矩阵序列的最小计算次数可以表示为递推式:m[i,j] = min{m[i,k] + m[k+1,j] + pi-1 * pk * pj} (i <= k < j)这个式子的意思是将矩阵序列Ai, Ai+1,...,Aj-1, Aj划分为两个子序列Ai, Ai+1,...,Ak和Ak+1,...,Aj,然后在这两个子序列中分别计算矩阵乘积所需的最小计算次数,其中pi-1 * pk * pj表示计算Ai到Aj乘积时需要的乘法次数。

由此,我们可以得出矩阵连乘的递归算法:Matrix Chain Multiply(A, p, i, j)if i == jreturn A[i]elsek = iM = Matrix Chain Multiply(A, p, i, k)N = Matrix Chain Multiply(A, p, k+1, j)return M * N其中,A是矩阵序列,p是矩阵的行列数,i和j表示矩阵序列的起止下标。

在递归过程中,我们用k将矩阵序列划分为两个部分,并分别计算左边和右边的矩阵乘积。

最后将两个部分的计算结果相乘即可。

这种算法的时间复杂度为O(n^3),在处理大规模的矩阵乘积时效率较低。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Strassen 矩阵相乘算法代码#include<tchar.h>#include<iostream>#include<ctime>#include<Windows.h>usingnamespace std;template<typename T>class Strassen_class {public:void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize);void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize);void MUL(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize);//朴素算法实现void FillMatrix(T** MatrixA, T** MatrixB, int length);//A,B矩阵赋值void PrintMatrix(T **MatrixA, int MatrixSize);//打印矩阵void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法实现};template<typename T>void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize) {for (int i = 0; i <MatrixSize; i++){for (int j = 0; j <MatrixSize; j++){MatrixResult[i][j] = MatrixA[i][j] + MatrixB[i][j];}}}template<typename T>void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize) {for (int i = 0; i <MatrixSize; i++){for (int j = 0; j <MatrixSize; j++){MatrixResult[i][j] = MatrixA[i][j] - MatrixB[i][j];}}}template<typename T>void Strassen_class<T>::MUL(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize) {for (int i = 0; i<MatrixSize; i++){for (int j = 0; j<MatrixSize; j++){MatrixResult[i][j] = 0;for (int k = 0; k<MatrixSize; k++){MatrixResult[i][j] = MatrixResult[i][j] + MatrixA[i][k] * MatrixB[k][j];}}}}/*c++使用二维数组,申请动态内存方法申请int **A;A = new int *[desired_array_row];for ( int i = 0; i < desired_array_row; i++)A[i] = new int [desired_column_size];释放for ( int i = 0; i < your_array_row; i++)delete [] A[i];delete[] A;*/template<typename T>void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC){int HalfSize = N / 2;int newSize = N / 2;if (N<= 64) //分治门槛,小于这个值时不再进行递归计算,而是采用常规矩阵计算方法{MUL(MatrixA, MatrixB, MatrixC, N);}else{T** A11;T** A12;T** A21;T** A22;T** B11;T** B12;T** B21;T** B22;T** C11;T** C12;T** C21;T** C22;T** M1;T** M2;T** M3;T** M4;T** M5;T** M6;T** M7;T** AResult;T** BResult;//making a 1 diminsional pointer based array.A11 = new T *[newSize];A12 = new T *[newSize];A21 = new T *[newSize];A22 = new T *[newSize];B11 = new T *[newSize];B12 = new T *[newSize];B21 = new T *[newSize];B22 = new T *[newSize];C11 = new T *[newSize];C12 = new T *[newSize];C21 = new T *[newSize];C22 = new T *[newSize];M1 = new T *[newSize];M2 = new T *[newSize];M3 = new T *[newSize];M4 = new T *[newSize];M5 = new T *[newSize];M6 = new T *[newSize];M7 = new T *[newSize];AResult = new T *[newSize];BResult = new T *[newSize];int newLength = newSize;//making that 1 diminsional pointer based array , a 2D pointer based array for (int i = 0; i < newSize; i++){A11[i] = new T[newLength];A12[i] = new T[newLength];A21[i] = new T[newLength];A22[i] = new T[newLength];B11[i] = new T[newLength];B12[i] = new T[newLength];B21[i] = new T[newLength];B22[i] = new T[newLength];C11[i] = new T[newLength];C12[i] = new T[newLength];C21[i] = new T[newLength];C22[i] = new T[newLength];M1[i] = new T[newLength];M2[i] = new T[newLength];M3[i] = new T[newLength];M4[i] = new T[newLength];M5[i] = new T[newLength];M6[i] = new T[newLength];M7[i] = new T[newLength];AResult[i] = new T[newLength];BResult[i] = new T[newLength];}//splitting input Matrixes, into 4 submatrices each.for (int i = 0; i <N / 2; i++){for (int j = 0; j <N / 2; j++){A11[i][j] = MatrixA[i][j];A12[i][j] = MatrixA[i][j + N / 2];A21[i][j] = MatrixA[i + N / 2][j];A22[i][j] = MatrixA[i + N / 2][j + N / 2];B11[i][j] = MatrixB[i][j];B12[i][j] = MatrixB[i][j + N / 2];B21[i][j] = MatrixB[i + N / 2][j];B22[i][j] = MatrixB[i + N / 2][j + N / 2];}}//here we calculate M1..M7 matrices .//M1[][]ADD(A11, A22, AResult, HalfSize);ADD(B11, B22, BResult, HalfSize); //p5=(a+d)*(e+h)Strassen(HalfSize, AResult, BResult, M1); //now that we need to multiply this , we use the strassen itself .//M2[][]ADD(A21, A22, AResult, HalfSize); //M2=(A21+A22)B11 p3=(c+d)*eStrassen(HalfSize, AResult, B11, M2); //Mul(AResult,B11,M2);//M3[][]SUB(B12, B22, BResult, HalfSize); //M3=A11(B12-B22) p1=a*(f-h)Strassen(HalfSize, A11, BResult, M3); //Mul(A11,BResult,M3);//M4[][]SUB(B21, B11, BResult, HalfSize); //M4=A22(B21-B11) p4=d*(g-e)Strassen(HalfSize, A22, BResult, M4); //Mul(A22,BResult,M4);//M5[][]ADD(A11, A12, AResult, HalfSize); //M5=(A11+A12)B22 p2=(a+b)*hStrassen(HalfSize, AResult, B22, M5); //Mul(AResult,B22,M5);//M6[][]SUB(A21, A11, AResult, HalfSize);ADD(B11, B12, BResult, HalfSize); //M6=(A21-A11)(B11+B12)p7=(c-a)(e+f)Strassen(HalfSize, AResult, BResult, M6); //Mul(AResult,BResult,M6);//M7[][]SUB(A12, A22, AResult, HalfSize);ADD(B21, B22, BResult, HalfSize); //M7=(A12-A22)(B21+B22)p6=(b-d)*(g+h)Strassen(HalfSize, AResult, BResult, M7); //Mul(AResult,BResult,M7);//C11 = M1 + M4 - M5 + M7;ADD(M1, M4, AResult, HalfSize);SUB(M7, M5, BResult, HalfSize);ADD(AResult, BResult, C11, HalfSize);//C12 = M3 + M5;ADD(M3, M5, C12, HalfSize);//C21 = M2 + M4;ADD(M2, M4, C21, HalfSize);//C22 = M1 + M3 - M2 + M6;ADD(M1, M3, AResult, HalfSize);SUB(M6, M2, BResult, HalfSize);ADD(AResult, BResult, C22, HalfSize);//at this point , we have calculated the c11..c22 matrices, and now we are going to //put them together and make a unit matrix which would describe our resulting Matrix.//组合小矩阵到一个大矩阵for (int i = 0; i <N / 2; i++){for (int j = 0; j <N / 2; j++){MatrixC[i][j] = C11[i][j];MatrixC[i][j + N / 2] = C12[i][j];MatrixC[i + N / 2][j] = C21[i][j];MatrixC[i + N / 2][j + N / 2] = C22[i][j];}}// 释放矩阵内存空间for (int i = 0; i < newLength; i++){delete[] A11[i]; delete[] A12[i]; delete[] A21[i];delete[] A22[i];delete[] B11[i]; delete[] B12[i]; delete[] B21[i];delete[] B22[i];delete[] C11[i]; delete[] C12[i]; delete[] C21[i];delete[] C22[i];delete[] M1[i]; delete[] M2[i]; delete[] M3[i]; delete[] M4[i];delete[] M5[i]; delete[] M6[i]; delete[] M7[i];delete[] AResult[i]; delete[] BResult[i];}delete[] A11; delete[] A12; delete[] A21; delete[] A22;delete[] B11; delete[] B12; delete[] B21; delete[] B22;delete[] C11; delete[] C12; delete[] C21; delete[] C22;delete[] M1; delete[] M2; delete[] M3; delete[] M4; delete[] M5;delete[] M6; delete[] M7;delete[] AResult;delete[] BResult;}//end of else}template<typename T>void Strassen_class<T>::FillMatrix(T** MatrixA, T** MatrixB, int length){for (int row = 0; row<length; row++){for (int column = 0; column<length; column++){MatrixB[row][column] = (MatrixA[row][column] = rand() % 5);//matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht}}}template<typename T>void Strassen_class<T>::PrintMatrix(T **MatrixA, int MatrixSize){cout << endl;for (int row = 0; row<MatrixSize; row++){for (int column = 0; column<MatrixSize; column++){cout <<MatrixA[row][column] <<"\t";if ((column + 1) % ((MatrixSize)) == 0)cout << endl;}}cout << endl;}int_tmain(int argc, _TCHAR* argv[]){Strassen_class<int> stra;//定义Strassen_class类对象int MatrixSize = 0;int** MatrixA; //存放矩阵Aint** MatrixB; //存放矩阵Bint** MatrixC; //存放结果矩阵clock_t startTime_For_Normal_Multipilication;clock_t endTime_For_Normal_Multipilication;clock_t startTime_For_Strassen;clock_t endTime_For_Strassen;srand(time(0));cout <<"\n请输入矩阵大小(必须是2的幂指数值(例如:32,64,512,..): ";cin >> MatrixSize;int N = MatrixSize;//for readiblity.//申请内存MatrixA = new i nt *[MatrixSize];MatrixB = new i nt *[MatrixSize];MatrixC = new i nt *[MatrixSize];for (int i = 0; i < MatrixSize; i++){MatrixA[i] = new i nt[MatrixSize];MatrixB[i] = new i nt[MatrixSize];MatrixC[i] = new i nt[MatrixSize];}stra.FillMatrix(MatrixA, MatrixB, MatrixSize); //矩阵赋值//*******************conventional multiplication testcout <<"朴素矩阵算法开始时钟: "<< (startTime_For_Normal_Multipilication = clock());stra.MUL(MatrixA, MatrixB, MatrixC, MatrixSize);//朴素矩阵相乘算法 T(n) = O(n^3)cout <<"\n朴素矩阵算法结束时钟: "<< (endTime_For_Normal_Multipilication = clock());cout <<"\n矩阵运算结果... \n";stra.PrintMatrix(MatrixC, MatrixSize);//*******************Strassen multiplication testcout <<"\nStrassen算法开始时钟: "<< (startTime_For_Strassen = clock());stra.Strassen(N, MatrixA, MatrixB, MatrixC); //strassen矩阵相乘算法cout <<"\nStrassen算法结束时钟: "<< (endTime_For_Strassen = clock());cout <<"\n矩阵运算结果... \n";stra.PrintMatrix(MatrixC, MatrixSize);cout <<"矩阵大小 "<< MatrixSize;cout <<"\n朴素矩阵算法: "<< (endTime_For_Normal_Multipilication -startTime_For_Normal_Multipilication) <<" Clocks.."<< (endTime_For_Normal_Multipilication - startTime_For_Normal_Multipilication) / CLOCKS_PER_SEC<<" Sec";cout <<"\nStrassen算法:"<< (endTime_For_Strassen - startTime_For_Strassen) <<" Clocks.."<< (endTime_For_Strassen - startTime_For_Strassen) / CLOCKS_PER_SEC<<" Sec\n";system("Pause");return 0;}。

相关文档
最新文档