国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

  1. Toy模板網(wǎng)首頁(yè)
  2. >Toy博客

矩陣乘法的三種算法(蠻力嵌套循環(huán)法，分治遞歸法，Strassen法)

2年前作者：GodFishhh分類：Toy博客閱讀(16)違法舉報(bào)

這篇具有很好參考價(jià)值的文章主要介紹了矩陣乘法的三種算法(蠻力嵌套循環(huán)法，分治遞歸法，Strassen法)。希望對(duì)大家有所幫助。如果存在錯(cuò)誤或未考慮完全的地方，請(qǐng)大家不吝賜教，您也可以點(diǎn)擊"舉報(bào)違法"按鈕提交疑問。

目錄

一.矩陣乘法的嵌套循環(huán)算法

二.矩陣乘法的遞歸算法

三.矩陣乘法的Strassen算法

一.矩陣乘法的嵌套循環(huán)算法

偽代碼：

矩陣乘法算法,算法導(dǎo)論,算法,算法

C++代碼：

//1.矩陣乘法的嵌套循環(huán)算法
#include<iostream>
using namespace std;

void Square_MA_MU(int a[][3],int b[][3],int c[][3],int n) //傳遞二維數(shù)組參數(shù)時(shí)必須要確定列數(shù)
{
	for (int i = 0; i < n; i++)  //行遍歷
	{
		for(int j=0;j<n;j++) //列遍歷
		{
			for (int x = 0; x < n; x++)
			{
				c[i][j] += a[x][i] * b[j][x]; //一行一行的元素計(jì)算
			}
		}
	}
}

int main()
{
	int a1[3][3]
	{
		1,1,1,
		2,2,2,
		3,3,3
	};
	int b1[3][3]
	{
		2,2,2,
		1,1,1,
		3,3,3
	};
	int c1[3][3] =
	{
		0,0,0,
		0,0,0,
		0,0,0
	};//進(jìn)行初始化
	cout << "矩陣相乘前的c1： " << endl;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << c1[i][j] << " ";
		}
		cout << endl;
	}
	Square_MA_MU(a1, b1, c1, 3);
	cout << "a1*b1得到的c1：" << endl;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << c1[i][j]<<" ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

二.矩陣乘法的遞歸算法

偽代碼：

矩陣乘法算法,算法導(dǎo)論,算法,算法

C++代碼：

#include<iostream>
using namespace std;

void matrix_multi_recursive(int a[][8], int m, int n, int b[][8], int p, int q, int size, int c[][8]) //m,n是矩陣a的位置參數(shù)，p,q是矩陣b
{
	if (size == 1)
	{
		c[m][q] += a[m][n] * b[p][q];
	}
	else
	{
		int half_size = size / 2;
		//分塊進(jìn)行遞歸運(yùn)算，分塊的基本原則為 half_size 即為 size/2 
		//初始狀態(tài)下共分八塊，再依次遞歸求得矩陣相乘的結(jié)果
		matrix_multi_recursive(a, m, n, b, p, q, half_size, c);
		matrix_multi_recursive(a, m, n + half_size, b, p + half_size, q, half_size, c);
		matrix_multi_recursive(a, m, n, b, p, q + half_size, half_size, c);
		matrix_multi_recursive(a, m, n + half_size, b, p + half_size, q + half_size, half_size, c);
		matrix_multi_recursive(a, m + half_size, n, b, p, q, half_size, c);
		matrix_multi_recursive(a, m + half_size, n + half_size, b, p + half_size, q, half_size, c);
		matrix_multi_recursive(a, m + half_size, n, b, p, q + half_size, half_size, c);
		matrix_multi_recursive(a, m + half_size, n + half_size, b, p + half_size, q + half_size, half_size, c);
	}
}

void print(int c[][8], int size)
{
	int i, j;
	for (i = 0; i < size; i++)
	{
		for (j = 0; j < size; j++)
		{
			cout << c[i][j] << " ";
		}
		cout << endl;
	}
}



int main()
{
	int a[8][8] = 
	{ 
	{1,2,3,4,5,6,7,8},
	{2,3,4,5,6,7,8,9},
	{3,4,5,6,7,8,9,10},
	{4,5,6,7,8,9,10,11},
	{5,6,7,8,9,10,11,12},
	{6,7,8,9,10,11,12,13},
	{7,8,9,10,11,12,13,14},
	{8,9,10,11,12,13,14,15}
	};

	int b[8][8] =
	{
	{10,11,12,13,14,15,16,17},
	{11,12,13,14,15,16,17,18},
	{12,13,14,15,16,17,18,19},
	{13,14,15,16,17,18,19,20},
	{14,15,16,17,18,19,20,21},
	{15,16,17,18,19,20,21,22},
    {16,17,18,19,20,21,22,23},
	{17,18,19,20,21,22,23,24}
	};
	int c[8][8];
	for (int i = 0; i < 8; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			c[i][j] = 0;
		}
	}
	matrix_multi_recursive(a, 0, 0, b, 0, 0, 8, c);
	print(c, 8);
	return 0;
	system("pause");
	return 0;
}

原理：矩陣乘法的分塊運(yùn)算：

【2.5】矩陣分塊相乘 - 知乎 (zhihu.com)

復(fù)雜度：

矩陣乘法算法,算法導(dǎo)論,算法,算法

三.矩陣乘法的Strassen算法

偽代碼：

矩陣乘法算法,算法導(dǎo)論,算法,算法

C++代碼：

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;
 
 
template <typename T>
class Strassen
{
public:
	void ADD(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void SUB(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void NormalMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void StrassenMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void FillMatrix(T **  MatrixA, T ** MatrixB, int size);//給A、B矩陣賦初值
	int   GetMatrixSum(T ** Matrix, int size);
	//用來計(jì)算矩陣各個(gè)元素的和，如果兩種算法得出的矩陣的和相等則認(rèn)為算法正確。
};
 
template <typename T>
void Strassen<T>::ADD(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = MatrixA[i][j] + MatrixB[i][j];
		}
	}
}
 
template <typename T>
void Strassen<T>::SUB(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = MatrixA[i][j] - MatrixB[i][j];
		}
	}
}

template <typename T>
void Strassen<T>::NormalMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = 0;
			for(int k = 0; k < size; k++)
				MatrixResult[i][j] += MatrixA[i][k] * MatrixB[k][j];
		}
	}
}
 
template <typename T>
void Strassen<T>::FillMatrix(T **  MatrixA, T ** MatrixB, int size)//給A、B矩陣賦初值
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixA[i][j] = MatrixB[i][j] = rand() % 5; 
		}
	}	
}
 
template <typename T>
void Strassen<T>::StrassenMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	// if ( size <= 64 )    
	//分治門檻，小于這個(gè)值時(shí)不再進(jìn)行遞歸計(jì)算，而是采用常規(guī)矩陣計(jì)算方法
	// {
	// 	NormalMul(MatrixA, MatrixB, MatrixResult, size);
	// }
	if(size == 1)
	{
		MatrixResult[0][0] = MatrixA[0][0] * MatrixB[0][0];
	}
	else
	{
		int half_size = size / 2;
		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 ** MatrixTemp1; T ** MatrixTemp2;
 
		A11 = new int * [half_size];
		A12 = new int * [half_size];
		A21 = new int * [half_size];
		A22 = new int * [half_size];
 
		B11 = new int * [half_size];
		B12 = new int * [half_size];
		B21 = new int * [half_size];
		B22 = new int * [half_size];
 
		C11 = new int * [half_size];
		C12 = new int * [half_size];
		C21 = new int * [half_size];
		C22 = new int * [half_size];
 
		M1 = new int * [half_size];
		M2 = new int * [half_size];
		M3 = new int * [half_size];
		M4 = new int * [half_size];
		M5 = new int * [half_size];
		M6 = new int * [half_size];
		M7 = new int * [half_size];
		MatrixTemp1 = new int * [half_size];
		MatrixTemp2 = new int * [half_size];
 
		for(int i = 0; i < half_size; i++)
		{
			A11[i] = new int[half_size];	
			A12[i] = new int[half_size];	
			A21[i] = new int[half_size];	
			A22[i] = new int[half_size];
			
			B11[i] = new int[half_size];	
			B12[i] = new int[half_size];	
			B21[i] = new int[half_size];	
			B22[i] = new int[half_size];
			
			C11[i] = new int[half_size];	
			C12[i] = new int[half_size];	
			C21[i] = new int[half_size];	
			C22[i] = new int[half_size];
 
			M1[i] = new int[half_size];	
			M2[i] = new int[half_size];	
			M3[i] = new int[half_size];	
			M4[i] = new int[half_size];
			M5[i] = new int[half_size];	
			M6[i] = new int[half_size];	
			M7[i] = new int[half_size];
 
			MatrixTemp1[i] = new int[half_size];	
			MatrixTemp2[i] = new int[half_size];
		}
 
		//賦值
		for(int i = 0; i < half_size; i++)
		{
			for(int j = 0; j < half_size; j++)
			{
				A11[i][j] = MatrixA[i][j];
				A12[i][j] = MatrixA[i][j+half_size];
				A21[i][j] = MatrixA[i+half_size][j];
				A22[i][j] = MatrixA[i+half_size][j+half_size];
 
				B11[i][j] = MatrixB[i][j];
				B12[i][j] = MatrixB[i][j+half_size];
				B21[i][j] = MatrixB[i+half_size][j];
				B22[i][j] = MatrixB[i+half_size][j+half_size];
			}
		}		
 
		//calculate M1
		ADD(A11, A22, MatrixTemp1, half_size);
		ADD(B11, B22, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M1,half_size);
 
		//calculate M2
		ADD(A21, A22, MatrixTemp1, half_size);
		StrassenMul(MatrixTemp1, B11, M2, half_size);
 
		//calculate M3
		SUB(B12, B22, MatrixTemp1, half_size);
		StrassenMul(A11, MatrixTemp1, M3, half_size);
 
 
		//calculate M4
		SUB(B21, B11, MatrixTemp1, half_size);
		StrassenMul(A22, MatrixTemp1, M4, half_size);
 
		//calculate M5
		ADD(A11, A12, MatrixTemp1, half_size);
		StrassenMul(MatrixTemp1, B22, M5, half_size);
 
		//calculate M6
		SUB(A21, A11, MatrixTemp1, half_size);
		ADD(B11, B12, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M6, half_size);
 
		//calculate M7
		SUB(A12, A22, MatrixTemp1, half_size);
		ADD(B21, B22, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M7, half_size);
 
		//C11
		ADD(M1, M4, C11, half_size);
		SUB(C11, M5, C11, half_size);
		ADD(C11, M7, C11, half_size);
 
		//C12
		ADD(M3, M5, C12, half_size);
 
		//C21
		ADD(M2, M4, C21, half_size);
 
		//C22
		SUB(M1, M2, C22, half_size);
		ADD(C22, M3, C22, half_size);
		ADD(C22, M6, C22, half_size);
 
		//賦值
		for(int i = 0; i < half_size; i++)
		{
			for(int j = 0; j < half_size; j++)
			{
				MatrixResult[i][j] = C11[i][j];
				MatrixResult[i][j+half_size] = C12[i][j];
				MatrixResult[i+half_size][j] = C21[i][j];
				MatrixResult[i+half_size][j+half_size] = C22[i][j];
			}
		}
 
		//釋放申請(qǐng)的內(nèi)存
		for(int i = 0; i < half_size; 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[] MatrixTemp1[i];	
			delete[] MatrixTemp2[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[] MatrixTemp1;	
		delete[] MatrixTemp2;
	}
}
 
template <typename T>
int   Strassen<T>::GetMatrixSum(T ** Matrix, int size)
{
	int sum = 0;
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			sum += Matrix[i][j];
		}
	}	
	return sum;
}
 
int main()
{
	long startTime_normal, endTime_normal;
	long startTime_strasse, endTime_strassen;
 
	//srand(time(0));
 
	Strassen<int> stra;
	int N;
	cout<<"please input the size of Matrix,and the size must be the power of 2:"<<endl;
	cin>>N;
 
	int ** Matrix1 = new int * [N];
	int ** Matrix2 = new int * [N];
	int ** Matrix3 = new int * [N];
	for(int i=0;i<N;i++)
	{
		Matrix1[i] = new int[N];
		Matrix2[i] = new int[N];
		Matrix3[i] = new int[N];
	}
 
	stra.FillMatrix(Matrix1, Matrix2,N);
 
	cout << "樸素算法開始時(shí)間：" << (startTime_normal = clock()) << endl;
	stra.NormalMul(Matrix1, Matrix2, Matrix3,N);
	cout << "樸素算法結(jié)束時(shí)間：" << (endTime_normal = clock()) << endl;
	cout << "總時(shí)間:" << endTime_normal-startTime_normal << endl;
	cout << "sum = " << stra.GetMatrixSum(Matrix3,N) << ';' << endl;
 
	cout << "Strassen算法開始時(shí)間：" << (startTime_strasse= clock()) << endl;
	stra.StrassenMul(Matrix1,Matrix2,Matrix3,N);
	cout << "Strassen算法結(jié)束時(shí)間：" << (endTime_strassen = clock()) << endl;
	cout << "總時(shí)間:" << endTime_strassen-startTime_strasse << endl;
	cout << "sum = " << stra.GetMatrixSum(Matrix3,N) << ';' << endl;
}

核心思想：令遞歸樹不那么茂盛一點(diǎn)，即只進(jìn)行七次遞歸而不是八次。

復(fù)雜度：

矩陣乘法算法,算法導(dǎo)論,算法,算法文章來源地址http://www.zghlxwxcb.cn/news/detail-649370.html

到了這里，關(guān)于矩陣乘法的三種算法(蠻力嵌套循環(huán)法，分治遞歸法，Strassen法)的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點(diǎn)僅代表作者本人，不代表本站立場(chǎng)。本站僅提供信息存儲(chǔ)空間服務(wù)，不擁有所有權(quán)，不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載，請(qǐng)注明出處： 如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實(shí)不符，請(qǐng)點(diǎn)擊違法舉報(bào)進(jìn)行投訴反饋，一經(jīng)查實(shí)，立即刪除！

領(lǐng)支付寶紅包贊助服務(wù)器費(fèi)用

相關(guān)文章

  • Java嵌套循環(huán)的使用與九九乘法表的輸出

    嵌套循環(huán)：將一個(gè)循環(huán)結(jié)構(gòu)A聲明在另一個(gè)循環(huán)結(jié)構(gòu)B的循環(huán)體中，就構(gòu)成了嵌套循環(huán) ????????外層循環(huán)：循環(huán)結(jié)構(gòu)B ????????內(nèi)層循環(huán)：循環(huán)結(jié)構(gòu)A 說明 ????????①內(nèi)層循環(huán)結(jié)構(gòu)遍歷一遍，只相當(dāng)于外層循環(huán)循環(huán)體執(zhí)行了一次 ????????②假設(shè)外層循環(huán)需要執(zhí)行m次

    2023年04月18日
    瀏覽(26)
  • Python---練習(xí)：使用for循環(huán)嵌套實(shí)現(xiàn)打印九九乘法表

    Python---練習(xí)：使用for循環(huán)嵌套實(shí)現(xiàn)打印九九乘法表

    思考： 外層 循環(huán)主要用于控制循環(huán)的 行數(shù) ， 內(nèi)層 循環(huán)用于控制 列數(shù)。 基本語法： 序列1? 序列2 ，就可以是range(1, 10)? ?-----也就是從1，到9。 參考while循環(huán)： 相關(guān)鏈接Python---練習(xí)：使用while嵌套循環(huán)打印 9 x 9乘法表-CSDN博客 最終代碼：

    2024年02月08日
    瀏覽(19)
  • 【數(shù)據(jù)結(jié)構(gòu)】稀疏矩陣存儲(chǔ)的三種方法及三元組表示稀疏矩陣轉(zhuǎn)置算法的兩種實(shí)現(xiàn) —— C++

    【數(shù)據(jù)結(jié)構(gòu)】稀疏矩陣存儲(chǔ)的三種方法及三元組表示稀疏矩陣轉(zhuǎn)置算法的兩種實(shí)現(xiàn) —— C++

    1. 三元組順序表數(shù)據(jù)結(jié)構(gòu) 注意：data[]中的元素是按行存儲(chǔ)或者按列存儲(chǔ)的，所以 在將三元組逆置時(shí)，不能簡(jiǎn)單地將行列下標(biāo)對(duì)換，data[]數(shù)組中元素的順序也需要重新排列 2. 三元組表示稀疏矩陣轉(zhuǎn)置算法1 3. 三元組表示稀疏矩陣轉(zhuǎn)置算法2：快速轉(zhuǎn)置 為了 便于隨機(jī)存取任意一

    2024年02月05日
    瀏覽(21)

  • Java的三種循環(huán)

    1.1 switch語句結(jié)構(gòu)（掌握） 1. 格式： 復(fù)制 2. 執(zhí)行流程： 首先計(jì)算出表達(dá)式的值 其次，和case依次比較，一旦有對(duì)應(yīng)的值，就會(huì)執(zhí)行相應(yīng)的語句，在執(zhí)行的過程中，遇到break就會(huì)結(jié)束。 最后，如果所有的case都和表達(dá)式的值不匹配，就會(huì)執(zhí)行default語句體部分，然后程序結(jié)束掉。

    2024年02月21日
    瀏覽(17)

  • java跳出for循環(huán)的三種常見方法

    這篇文章主要給大家介紹了關(guān)于java跳出for循環(huán)的三種常見方法,需要的朋友可以參考下 一、 break語句：使用break語句可以結(jié)束整個(gè)for循環(huán)的執(zhí)行： 當(dāng) i 等于5時(shí)， break 語句會(huì)將控制流程跳出 for 循環(huán)從而停止后續(xù)代碼的執(zhí)行。 二、?return語句：如果你想要跳出當(dāng)前方法并且停止

    2024年04月23日
    瀏覽(19)
  • Python中退出While循環(huán)的三種方法舉例

    Python中退出While循環(huán)的三種方法舉例

    在Python學(xué)習(xí)及編程應(yīng)用中，常會(huì)使用while循環(huán)，對(duì)while循環(huán)條件設(shè)置不當(dāng)可能導(dǎo)致進(jìn)入死循環(huán)，本文將舉例說明三種退出while循環(huán)的方法。 利用input函數(shù)使得輸入值傳遞到while之后的條件判斷句中，使while后的結(jié)果為False。 舉例： 程序1： 運(yùn)行結(jié)果舉例 使用input將輸入的值，通過

    2024年02月09日
    瀏覽(24)

  • 生產(chǎn)項(xiàng)目中基于springboot項(xiàng)目解決循環(huán)依賴的三種方式

    在生產(chǎn)項(xiàng)目中，可以使用Spring Boot框架來快速開發(fā)Spring應(yīng)用程序。Spring Boot提供了一種方便的方式來創(chuàng)建獨(dú)立的，基于Spring的應(yīng)用程序，并且有著高度的自動(dòng)化配置和開箱即用的特性。 可以使用@Lazy注解來控制Bean的延遲初始化，同時(shí)可以使用AOP切面編程來解決循環(huán)依賴問題。

    2024年02月11日
    瀏覽(22)

  • 1.矩陣的三種不變因子

    本文主要介紹多項(xiàng)式矩陣的基本概念和等價(jià)，用于為相似標(biāo)準(zhǔn)型進(jìn)行鋪墊 此處將由數(shù)組成的矩陣拓展為以多項(xiàng)式為元的矩陣，即多項(xiàng)式矩陣 【定義】多項(xiàng)式矩陣的秩 設(shè) A ( λ ) ∈ F [ λ ] m × n ， A ( λ ) ≠ 0 A(lambda)in F[lambda]^{mtimes n}，A(lambda)neq0 A ( λ ) ∈ F [ λ ] m × n ， A

    2024年01月20日
    瀏覽(19)
  • 蠻力算法之深度優(yōu)先遍歷和廣度優(yōu)先遍歷——圖的深度優(yōu)先遍歷和廣度優(yōu)先遍歷，附帶案例：迷宮問題及矩陣中傳染性傳播問題

    蠻力算法之深度優(yōu)先遍歷和廣度優(yōu)先遍歷——圖的深度優(yōu)先遍歷和廣度優(yōu)先遍歷，附帶案例：迷宮問題及矩陣中傳染性傳播問題

    這兩種搜索方法本質(zhì)上都是基于蠻力法思路 這兩種搜索方法對(duì)有向圖和無向圖都適用 1.1 鄰接矩陣 鄰接矩陣示意圖： 1.2 鄰接表 注意：邊結(jié)點(diǎn)代表的是圖中的邊，而并非圖中的結(jié)點(diǎn)；頭結(jié)點(diǎn)才表示圖中的結(jié)點(diǎn)；頭結(jié)點(diǎn)身后所連接的為邊結(jié)點(diǎn) 鄰接表示意圖：（一般默認(rèn)為出邊

    2024年02月05日
    瀏覽(19)
  • 矩陣算法之矩陣乘法

    矩陣算法之矩陣乘法

    矩陣算法在圖像處理、神經(jīng)網(wǎng)絡(luò)、模式識(shí)別等領(lǐng)域有著廣泛的用途。 在矩陣乘法中，A矩陣和B矩陣可以做乘法運(yùn)算必須滿足A矩陣的列的數(shù)量等于B矩陣的行的數(shù)量。 運(yùn)算規(guī)則：A的每一行中的數(shù)字對(duì)應(yīng)乘以B的每一列的數(shù)字把結(jié)果相加起來。 1、當(dāng)矩陣A的列數(shù)（column）等于矩陣

    2024年02月11日
    瀏覽(22)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請(qǐng)作者喝杯咖啡吧~博客贊助

支付寶掃一掃領(lǐng)取紅包，優(yōu)惠每天領(lǐng)

二維碼1

領(lǐng)取紅包

二維碼2

領(lǐng)紅包