C++ MKL 计算矩阵相乘/矩阵转置相乘

已于 2024-08-18 21:04:51 修改
阅读量106 收藏
点赞数 3
分类专栏： mkl 文章标签： 算法
于 2024-08-18 21:03:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/reyyy/article/details/141305460
版权 
/*********************************************************************************************************
1.此子程序主要是用于求解矩阵的相乘
2.参数说明
传入的参数：二维数组Aa，Bb，维数int M, int K, int N
传出的参数：
*********************************************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "mkl.h"

double ** matrix_multiply(double **Aa, double **Bb, int M, int K, int N)
//M为A矩阵的行数；K为矩阵A的列数；N为矩阵B的列数, Aa * Bb
{

	const enum CBLAS_ORDER      Order = CblasRowMajor;
	const enum CBLAS_TRANSPOSE TransA = CblasNoTrans; //A没有转置
	const enum CBLAS_TRANSPOSE TransB = CblasNoTrans; //B没有转置

	int i, j, mm, nn;
	double alpha = 1.0;
	double beta = 0.0;
	double * A;
	double * B;
	double * C;
	double ** end_C;

	int lda = K;     //A的列 
	int ldb = N;     //B的列 
	int ldc = N;     //C的列 

	int A_num = M * K;
	int B_num = K * N;
	int C_num = M * N;

	//动态定义一维数组
	A = (double*)malloc(sizeof(double) * A_num);
	B = (double*)malloc(sizeof(double) * B_num);
	C = (double*)malloc(sizeof(double) * C_num);

	//动态定义二维数组
	end_C = (double**)malloc(sizeof(double*) * M);
	for (i = 0; i < M; i++)
	{
		end_C[i] = (double*)malloc(sizeof(double) * N);
	}

	//矩阵初始化
	for (i = 0; i < M * K; i++)
	{
		A[i] = 0.0;
	}

	for (i = 0; i < N * K; i++)
	{
		B[i] = 0.0;
	}

	for (i = 0; i < M * N; i++)
	{
		C[i] = 0.0;
	}

	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			end_C[i][j] = 0.0;
		}
	}


	//二维矩阵Aa按行内容转为一维矩阵
	mm = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < K; j++)
		{
			mm = i * K + j;
			A[mm] = Aa[i][j]; // Aa:M * K
		}
	}

	//二维矩阵Bb按行内容转为一维矩阵
	nn = 0;
	for (i = 0; i < K; i++)
	{
		for (j = 0; j < N; j++)
		{
			nn = i * N + j;
			B[nn] = Bb[i][j]; // Bb:K * N
		}
	}

	//MKL函数库矩阵相乘
	cblas_dgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);


	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			//end_C[j][i] = C[i*N + j];             //一维矩阵转二维矩阵，并完成转置工作
			end_C[i][j] = C[i*N + j];
		}
	}

	//释放
	free(A); A = NULL; free(B); B = NULL; free(C); C = NULL;

	return end_C;

	for (i = 0; i < N; i++)
	{
		free(end_C[i]); end_C[i] = NULL;  /*释放列*/
	}
	free(end_C); end_C = NULL;            /*释放行*/

}

double ** matrix_multiply_transpose(double **Aa, double **Bb, int M, int K, int N)
//M为A矩阵的行数；K为矩阵A的列数；N为矩阵B的列数, Aa transpose * Bb
{

	const enum CBLAS_ORDER      Order = CblasRowMajor;
	const enum CBLAS_TRANSPOSE TransA = CblasTrans; //转置A
	const enum CBLAS_TRANSPOSE TransB = CblasNoTrans; //B没有转置

	int i, j, mm, nn;
	double alpha = 1.0;
	double beta = 0.0;
	double * A;
	double * B;
	double * C;
	double ** end_C;

	int lda = K;     //A的列 
	int ldb = N;     //B的列 
	int ldc = N;     //C的列 

	int A_num = M * K;
	int B_num = M * N;
	int C_num = K * N;

	//动态定义一维数组
	A = (double*)malloc(sizeof(double) * A_num);
	B = (double*)malloc(sizeof(double) * B_num);
	C = (double*)malloc(sizeof(double) * C_num);

	//动态定义二维数组
	end_C = (double**)malloc(sizeof(double*) * K);
	for (i = 0; i < K; i++)
	{
		end_C[i] = (double*)malloc(sizeof(double) * N);
	}

	//矩阵初始化
	for (i = 0; i < M * K; i++)
	{
		A[i] = 0.0;
	}

	for (i = 0; i < N * M; i++)
	{
		B[i] = 0.0;
	}

	for (i = 0; i < K * N; i++)
	{
		C[i] = 0.0;
	}

	for (i = 0; i < K; i++)
	{
		for (j = 0; j < N; j++)
		{
			end_C[i][j] = 0.0;
		}
	}


	//二维矩阵Aa按行内容转为一维矩阵
	mm = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < K; j++)
		{
			mm = i * K + j;
			A[mm] = Aa[i][j]; // Aa:M * K
		}
	}

	//二维矩阵Bb按行内容转为一维矩阵
	nn = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			nn = i * N + j;
			B[nn] = Bb[i][j]; // Bb:M * N
		}
	}

	//MKL函数库矩阵相乘
	cblas_dgemm(Order, TransA, TransB, K, N, M, alpha, A, lda, B, ldb, beta, C, ldc);


	for (i = 0; i < K; i++)
	{
		for (j = 0; j < N; j++)
		{
			//end_C[j][i] = C[i*N + j];             //一维矩阵转二维矩阵，并完成转置工作
			end_C[i][j] = C[i*N + j];
		}
	}

	//释放
	free(A); A = NULL; free(B); B = NULL; free(C); C = NULL;

	return end_C;

	for (i = 0; i < N; i++)
	{
		free(end_C[i]); end_C[i] = NULL;  /*释放列*/
	}
	free(end_C); end_C = NULL;            /*释放行*/

}

void matrix_multiply_transpose_test() {

	printf("enter matrix_mult_transpose_test\n");

	int M = 2, K = 3, N = 1;
	double **Aa = (double**)malloc(sizeof(double*) * M);
	for (int i = 0; i < M; i++)
	{
		Aa[i] = (double*)malloc(sizeof(double) * K);
	}
	printf("Aa:\n");
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < K; j++)
		{
			Aa[i][j] = i + j;
			printf("%.0f,", Aa[i][j]);
		}
		printf("\n");
	}
	double **Bb = (double**)malloc(sizeof(double*) * M);
	for (int i = 0; i < M; i++)
	{
		Bb[i] = (double*)malloc(sizeof(double) * N);
	}
	printf("Bb:\n");
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			Bb[i][j] = i + j + 2;
			printf("%.0f,", Bb[i][j]);
		}
		printf("\n");
	}
	double ** Cc = matrix_multiply_transpose(Aa, Bb, M, K, N);
	printf("Aa transpose * Bb:\n");
	for (int i = 0; i < K; i++)
	{
		for (int j = 0; j < N; j++)
		{

			printf("%.0f,", Cc[i][j]);
		}
		printf("\n");
	}

	for (int i = 0; i < M; i++)
	{
		free(Aa[i]);  /*释放列*/
	}
	free(Aa);         /*释放行*/

	for (int i = 0; i < M; i++)
	{
		free(Bb[i]);   /*释放列*/

	}
	free(Bb);            /*释放行*/

	for (int i = 0; i < K; i++)
	{
		free(Cc[i]);  /*释放列*/
	}
	free(Cc);           /*释放行*/

	printf("leave matrix_mult_transpose_test\n");

}

void matrix_multiply_test() {

	printf("enter matrix_mult_test\n");

	int M = 3, K = 2, N = 1;
	double **Aa = (double**)malloc(sizeof(double*) * M);
	for (int i = 0; i < M; i++)
	{
		Aa[i] = (double*)malloc(sizeof(double) * K);
	}
	printf("Aa:\n");
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < K; j++)
		{
			Aa[i][j] = i + j;
			printf("%.0f,", Aa[i][j]);
		}
		printf("\n");
	}
	double **Bb = (double**)malloc(sizeof(double*) * K);
	for (int i = 0; i < K; i++)
	{
		Bb[i] = (double*)malloc(sizeof(double) * N);
	}
	printf("Bb:\n");
	for (int i = 0; i < K; i++)
	{
		for (int j = 0; j < N; j++)
		{
			Bb[i][j] = i + j + 2;
			printf("%.0f,", Bb[i][j]);
		}
		printf("\n");
	}
	double ** Cc = matrix_multiply(Aa, Bb, M, K, N);
	printf("Aa*Bb:\n");
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{

			printf("%.0f,", Cc[i][j]);
		}
		printf("\n");
	}

	for (int i = 0; i < M; i++)
	{
		free(Aa[i]);  /*释放列*/
	}
	free(Aa);         /*释放行*/

	for (int i = 0; i < K; i++)
	{
		free(Bb[i]);   /*释放列*/

	}
	free(Bb);            /*释放行*/

	for (int i = 0; i < M; i++)
	{
		free(Cc[i]);  /*释放列*/
	}
	free(Cc);           /*释放行*/

	printf("leave matrix_mult_test\n");

}



void main() {

	matrix_multiply_transpose_test();
	printf("\n");
	matrix_multiply_test();
	printf("\n");

	getchar();

}

rayyy9
关注
专栏目录
MKL学习杂记
liuyijie1990的博客
11-30 2090
Lapck学习杂记一 Lapck——》Fortran 77 1) 矩阵相乘 dgemm： dgemm (TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC) Purpose： C=αA B+βC M by N matrix Parameters： 1) TRANSA: 矩
C语言 Mkl 矩阵乘法,与MKL的矩阵乘法
weixin_35671421的博客
05-17 831
这是我使用的，以及对我有用的东西。char matdescra[6] = {'g', 'l', 'n', 'c', 'x', 'x'};/* https://software.intel.com/sites/products/documentation/hpc/mkl/mklman/GUID-34C8DB79-0139-46E0-8B53-99F3BEE7B2D4.htm#TBL2-6G: Gen...
MKL库矩阵乘法
AresGod的专栏
05-21 8644
MKL库矩阵乘法 Posted on 2008年09月3日by cici1020 我再次来学术一把。 我今天因为不想看3000多页的大文档，就在GOOGLE狂翻用Intel的Math Kernel Library的库如何作矩阵运算。最后还是看那个3000多页的大文档找到的解决方法。 前人栽树后人乘凉…… 关键词：Intel MKL MKL库 矩阵乘积 矩阵乘法 样例 例子
C语言 Mkl 矩阵乘法,Visual Studio下实现Eigen+Intel MKL的矩阵乘法
weixin_39815410的博客
05-17 642
科学计算过程中经常会用到线性代数运算，尤其是矩阵乘法，自己手写的C++代码想要赶上MATLAB几乎是不可能的。在C++中，谈到高性能计算就往往要用Intel MKL，但是用过的人都知道，这东西烦人的很，函数风格也怪异，不好用，一个简单的矩阵乘法函数dgemm的参数列表就老长老长。Eigen是一个相对来说十分优雅和好用的线性代数运算库(尤其是在Windows下，Blas，Lapack太麻烦，基本不考...
MKL的矩阵运算
chenlanjie842179335的专栏
10-06 1万+
矩阵与矩阵的乘法，分为双精度的cblas_sgemm和单精度的cblas_sgemm，两个函数的参数意义一样，只是类型不一样 运算式：C=alpha*A*B+beta*C  一般取alpha=1.0，beta=0.0 即计算式：C=A*B cblas_sgemm(CblasRowMajor, CblasNoTrans,CblasNoTrans,M,N,K,alpha,A,A的列数,B,B的
你不知道的那些关于MKL数学库的骚操作!
菜牙
05-24 2678
你不知道的那些关于MKL数学库的骚操作! 1、卷积 1.1、函数原型 cblas_sgemm(order,transA,transB,M,N,K,alpha,A,lda,B,ldb,beta,C，ldc); 1.2、函数作用 C=alphaAB+beta*C ，当alpha =1,beta =0 的情况下，等于两个矩阵相乘。 1.3、函数参数说明 参数1： 设置数据在内存中如何存储，ClasRowMajow 按行存储，ClasColMajow 按列存储,一般用ClasRowMajow。 参数2：Cblas
MKL 求解大型稀疏矩阵
05-04
inter MKL 求解大型稀疏矩阵 实例（C/C++）。适用与对称或者非对称 稀疏矩阵求解，求解速度非常快。
mul.zip.rar_矩阵相乘
09-24
8. **编程语言实现**：矩阵相乘算法可以使用各种编程语言实现，如C、C++、Python（NumPy库）、Java、Rust等，每种语言都有其特性和优势。 综上所述，了解和掌握矩阵相乘的优化技术对于提高计算效率至关重要。通过...
Optimization 注水问题.rar_数学计算_C/C++__数学计算_C/C++_
08-09
在IT领域，优化问题是一个广泛研究的议题，特别是在数学计算和C/C++编程中。"Optimization 注水问题.rar"这个资源显然包含了针对一个特定问题——注水问题的优化算法。这种问题通常出现在工程设计、经济学、物流规划...
MKL 求解大型稀疏复数矩阵
05-04
Intel MKL 求解大型稀疏复数矩阵 （C/C++）实例。 适用与求解大型对称或者非对称稀疏复数矩阵
C语言 Mkl 矩阵乘法,MKL库矩阵乘法
weixin_31299075的博客
05-17 945
我再次来学术一把。我今天因为不想看3000多页的大文档，就在GOOGLE狂翻用Intel的Math Kernel Library的库如何作矩阵运算。最后还是看那个3000多页的大文档找到的解决方法。前人栽树后人乘凉……关键词：Intel MKL MKL库 矩阵乘积 矩阵乘法 样例 例子 代码 标程 sample code这样以后人家都能搜到这里了:DMKL的大文档里，有各种matrix*matri...
mkl行主序、列主序转换——以cblas_sgemm为例
jnulzl的专栏
11-23 1572
本文 以mkl中的cblas_sgemm为例演示行主序、列主序调用方式以及相互调用。 cblas_sgemm接口: void cblas_sgemm (const CBLAS_LAYOUT Layout, const CBLAS_TRANSPOSE transa, const CBLAS_TRANSPOSE transb, const MKL_INT m, const MKL_INT n, con...
MKL学习——矩阵矩阵操作
风翼冰舟的博客
04-17 9193
前言前面介绍了BLAS Level 1中向量-向量操作，以及BLAS Level 2中矩阵-向量的操作，就剩下这一篇的BLAS Level 3中的矩阵-矩阵的操作了。对稀疏矩阵的操作以后等要用再看看。对基本的矩阵和向量运算的函数有所了解以后，就进行常用参数分析，以及实现了。所有函数概览 函数名称 缺失部分 描述 cblas_?gemm s,d,c,z 一般矩阵的矩阵-矩阵乘法
MKL——常用函数说明
shuzfan的专栏
10-14 3万+
Intel MKL，全称 Intel Math Kernel Library，提供经过高度优化和大量线程化处理的数学例程，面向性能要求极高的科学、工程及金融等领域的应用。MKL是一款商用函数库，但提供C、Fortran 和 Fortran 95的支持，但仅支持Intel自家旗下的CPU。在Intel CPU上，MKL的性能要远高于Eigen, 虽然OpenBLAS和其差距不是太大，但OpenBLAS
（原）mkl的cblas_sgemm和cblas_dgemm
weixin_33725126的博客
06-02 389
转载请注明出处： http://www.cnblogs.com/darkknightzh/p/5553336.html 参考网址： mkl-11.3.2-developer-reference-c_0.pdf（intel官网下载） http://goodluck1982.blog.sohu.com/94851969.html   void cblas_sgemm(const CBL...
矩阵转置运算简单总结
热门推荐
Jensen Lee的博客
10-23 5万+
矩阵转置的运算规律： （1）; （2）; （3）; （4）; （5）
MKL 进行矩阵向量运算
AresGod的专栏
05-22 3400
/* C source code is found in dgemm_example.c */ #define min(x,y) (((x) #include #include #include "mkl.h" int main() {     float *A, *B, *C;     int m, n, k, i, j;     int l,r;
MKL学习——向量操作
风翼冰舟的博客
04-13 1万+
前言推荐两个比较好的教程:BLAS (Basic Linear Algebra Subprograms) LAPACK for Windows命名规范BLAS基本线性代数子程序的函数命令都有一定规范，便于记忆<character> <name> <mod> ()character定义的是数据类型 s 实数域，单精度 c 复数域，单精度 d 实数域，双精度 z 复数域，双
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值