矩陣乘法快速演算法

A. 老師，矩陣相乘怎麼算

矩陣相乘要求前一個矩陣的行數和後一個的矩陣列數要相同，這樣你用前一個的第一行的數去乘以後一個第一列的對應的數而後相加，即求得第一行與第一列的乘數和，並填寫在第一個上面，以後每一行與每一列都這么算，並填寫在相應的位置即可。

B. 矩陣的乘法運算怎麼算

矩陣的乘法，首先要判定能不能作乘法，即要求作乘法時，前一個矩陣的列數與後一個矩陣的行數相等。

設矩陣A是m×n的、矩陣B是n×s的，乘法AB後得到矩陣C，則C為m×s的，如下圖所示。

• C11是由A的第一行與B的第一列對應相乘得到的，即C11=1×3+2×1+4×2=13。
  

• C32是由A的第三行與B的第二列對應相乘得到的，即C32=2×2+5×6+1×1=35。

其他元素也是同理，分別取A的某行與B的某列，將對應元素相乘求出。

C. 高數中的矩陣乘法要怎麼計算，方法步驟是什麼

矩陣相乘最重要的方法是一般矩陣乘積。它只有在第一個矩陣的列數（column）和第二個矩陣的行數（row）相同時才有意義。一般單指矩陣乘積時，指的便是一般矩陣乘積。

1、前一矩陣的第一行對應元乘以後一矩陣第一列對應元之和為新矩陣的第一行第一列的元素。

例如：1*0+1*1=1

2、前一矩陣的第一行對應元乘以後一矩陣第二列對應元之和為新矩陣的第一行第二列的元素。

例如：1*2+1*1=3

3、前一矩陣的第一行對應元乘以後一矩陣第三列對應元之和為新矩陣的第一行第三列的元素。

例如：1*3+1*2=5

4、前一矩陣的第二行對應元乘以後一矩陣第一列對應元之和為新矩陣的第二行第一列的元素。

例如：2*0+0*1=0

5、前一矩陣的第二行對應元乘以後一矩陣第二列對應元之和為新矩陣的第二行第二列的元素。

例如：2*2+0*1=4

6、前一矩陣的第二行對應元乘以後一矩陣第三列對應元之和為新矩陣的第二行第三列的元素。

例如：2*3+0*2=6

注意事項：

1、分清楚矩陣就是指數表與行列式不同，矩陣相乘就是兩個數表的運算。

2、自己多總結規律，就知道矩陣相乘是如何運算的了。

D. 線性代數中矩陣相乘如何計算啊

左邊矩陣的行的每一個元素 與右邊矩陣的列的對應的元素一一相乘然後加到一起形成新矩陣中的aij元素 i是左邊矩陣的第i行 j是右邊矩陣的第j列

例如 左邊矩陣：

2 3 4

1 4 5

右邊矩陣

1 2

2 3

1 3

相乘得到： 2×1+3×2+4×1 2×2+3×3+4×3

1×1+4×2+5×1 1×2+4×3+5×3

這樣2×2階的一個矩陣

(4)矩陣乘法快速演算法擴展閱讀:

矩陣乘法

(1) mxn的矩陣T乘向量x可以理解為將這個n維列向量線性映射為一個m維列向量：

(2) 而一個mxn矩陣乘nxL 矩陣就是先進行一個線性映射再進行一個線性映射.

這叫做線性映射的復合。線性映射的復合是另一個線性映射。映射T和映射S的復合記做：T o S.

將映射表示為矩陣。則線性映射的復合就是對應的矩陣相乘.

(3) 由於復合映射的前一個映射的目標空間是另一個的域空間。所以矩陣乘法要求第一個的列數要等於第二個的行數。

將新基矩陣T的每一行向量看做一個用原基向量（i,j,k,...）表示的一個新的軸/基，若共R行，即R維度，新的空間共R個軸，將X的每一列都看做為一組特徵向量，每一列的特徵相同都是n維的點（x11,x12,..,x1n）(x1表示第一列向量)，只是不同列的賦值不同。

相乘的結果為矩陣Y，那麼Y內的某個值，即是某列特徵在某個軸上的投影大小，Y的某行向量，即是所有特徵在某軸上的投影結果，Y的列向量，即是某個特徵（原坐標的一個點）在新的空間的投影/新值，R維的點（t1x1,t2x1,...,trx1）。

Y矩陣表示的是，原坐標中所有點，通過T坐標空間的轉換，得到的新的空間點集合。

E. 矩陣乘法如何計算

比如乘法AB
一、1）用A的第1行各個數與B的第1列各個數對應相乘後加起來，就是乘法結果中第1行第1列的數；
2）用A的第1行各個數與B的第2列各個數對應相乘後加起來，就是乘法結果中第1行第2列的數；
3）用A的第1行各個數與B的第3列各個數對應相乘後加起來，就是乘法結果中第1行第3列的數；
依次進行，
（直到）用A的第1行各個數與B的第末列各個數對應相乘後加起來，就是乘法結果中第1行第末列的的數，
二、1）用A的第2行各個數與B的第1列各個數對應相乘後加起來，就是乘法結果中第2行第1列的數；
2）用A的第2行各個數與B的第2列各個數對應相乘後加起來，就是乘法結果中第2行第2列的數；
3）用A的第2行各個數與B的第3列各個數對應相乘後加起來，就是乘法結果中第2行第3列的數；
依次進行，
（直到）用A的第2行各個數與B的第末列各個數對應相乘後加起來，就是乘法結果中第2行第末列的的數，
依次進行，
（直到）用A的第末行各個數與B的第1列各個數對應相乘後加起來，就是乘法結果中第末行第1列的數；
2）用A的第末行各個數與B的第2列各個數對應相乘後加起來，就是乘法結果中第末行第2列的數；
3）用A的第末行各個數與B的第3列各個數對應相乘後加起來，就是乘法結果中第末行第3列的數；
依次進行，
（直到）用A的第末行各個數與B的第末列各個數對應相乘後加起來，就是乘法結果中第末行第末列的的數。

F. 求助，有沒有矩陣相乘的快速演算法

演算法介紹
矩陣相乘在進行3D變換的時候是經常用到的。在應用中常用矩陣相乘的定義演算法對其進行計算。這個演算法用到了大量的循環和相乘運算，這使得演算法效率不高。而矩陣相乘的計算效率很大程度上的影響了整個程序的運行速度，所以對矩陣相乘演算法進行一些改進是必要的。
這里要介紹的矩陣演算法稱為斯特拉森方法，它是由v.斯特拉森在1969年提出的一個方法。
我們先討論二階矩陣的計算方法。
對於二階矩陣
a11 a12 b11 b12
A = a21 a22 B = b21 b22
先計算下面7個量(1)
x1 = (a11 + a22) * (b11 + b22); x2 = (a21 + a22) * b11; x3 = a11 * (b12 - b22); x4 = a22 * (b21 - b11); x5 = (a11 + a12) * b22; x6 = (a21 - a11) * (b11 + b12); x7 = (a12 - a22) * (b21 + b22);

再設C = AB。根據矩陣相乘的規則，C的各元素為(2)
c11 = a11 * b11 + a12 * b21 c12 = a11 * b12 + a12 * b22 c21 = a21 * b11 + a22 * b21 c22 = a21 * b12 + a22 * b22

比較(1)(2)，C的各元素可以表示為(3)
c11 = x1 + x4 - x5 + x7 c12 = x3 + x5 c21 = x2 + x4 c22 = x1 + x3 - x2 + x6

根據以上的方法，我們就可以計算4階矩陣了，先將4階矩陣A和B劃分成四塊2階矩陣，分別利用公式計算它們的乘積，再使用(1)(3)來計算出最後結果。
ma11 ma12 mb11 mb12
A4 = ma21 ma22 B4 = mb21 mb22
其中
a11 a12 a13 a14 b11 b12 b13 b14
ma11 = a21 a22 ma12 = a23 a24 mb11 = b21 b22 mb12 = b23 b24

a31 a32 a33 a34 b31 b32 b33 b34
ma21 = a41 a42 ma22 = a43 a44 mb21 = b41 b42 mb22 = b43 b44
實現
// 計算2X2矩陣 void Multiply2X2(float& fOut_11, float& fOut_12, float& fOut_21, float& fOut_22, float f1_11, float f1_12, float f1_21, float f1_22, float f2_11, float f2_12, float f2_21, float f2_22) { const float x1((f1_11 + f1_22) * (f2_11 + f2_22)); const float x2((f1_21 + f1_22) * f2_11); const float x3(f1_11 * (f2_12 - f2_22)); const float x4(f1_22 * (f2_21 - f2_11)); const float x5((f1_11 + f1_12) * f2_22); const float x6((f1_21 - f1_11) * (f2_11 + f2_12)); const float x7((f1_12 - f1_22) * (f2_21 + f2_22)); fOut_11 = x1 + x4 - x5 + x7; fOut_12 = x3 + x5; fOut_21 = x2 + x4; fOut_22 = x1 - x2 + x3 + x6; } // 計算4X4矩陣 void Multiply(CLAYMATRIX& mOut, const CLAYMATRIX& m1, const CLAYMATRIX& m2) { float fTmp[7][4]; // (ma11 + ma22) * (mb11 + mb22) Multiply2X2(fTmp[0][0], fTmp[0][1], fTmp[0][2], fTmp[0][3], m1._11 + m1._33, m1._12 + m1._34, m1._21 + m1._43, m1._22 + m1._44, m2._11 + m2._33, m2._12 + m2._34, m2._21 + m2._43, m2._22 + m2._44); // (ma21 + ma22) * mb11 Multiply2X2(fTmp[1][0], fTmp[1][1], fTmp[1][2], fTmp[1][3], m1._31 + m1._33, m1._32 + m1._34, m1._41 + m1._43, m1._42 + m1._44, m2._11, m2._12, m2._21, m2._22); // ma11 * (mb12 - mb22) Multiply2X2(fTmp[2][0], fTmp[2][1], fTmp[2][2], fTmp[2][3], m1._11, m1._12, m1._21, m1._22, m2._13 - m2._33, m2._14 - m2._34, m2._23 - m2._43, m2._24 - m2._44); // ma22 * (mb21 - mb11) Multiply2X2(fTmp[3][0], fTmp[3][1], fTmp[3][2], fTmp[3][3], m1._33, m1._34, m1._43, m1._44, m2._31 - m2._11, m2._32 - m2._12, m2._41 - m2._21, m2._42 - m2._22); // (ma11 + ma12) * mb22 Multiply2X2(fTmp[4][0], fTmp[4][1], fTmp[4][2], fTmp[4][3], m1._11 + m1._13, m1._12 + m1._14, m1._21 + m1._23, m1._22 + m1._24, m2._33, m2._34, m2._43, m2._44); // (ma21 - ma11) * (mb11 + mb12) Multiply2X2(fTmp[5][0], fTmp[5][1], fTmp[5][2], fTmp[5][3], m1._31 - m1._11, m1._32 - m1._12, m1._41 - m1._21, m1._42 - m1._22, m2._11 + m2._13, m2._12 + m2._14, m2._21 + m2._23, m2._22 + m2._24); // (ma12 - ma22) * (mb21 + mb22) Multiply2X2(fTmp[6][0], fTmp[6][1], fTmp[6][2], fTmp[6][3], m1._13 - m1._33, m1._14 - m1._34, m1._23 - m1._43, m1._24 - m1._44, m2._31 + m2._33, m2._32 + m2._34, m2._41 + m2._43, m2._42 + m2._44); // 第一塊 mOut._11 = fTmp[0][0] + fTmp[3][0] - fTmp[4][0] + fTmp[6][0]; mOut._12 = fTmp[0][1] + fTmp[3][1] - fTmp[4][1] + fTmp[6][1]; mOut._21 = fTmp[0][2] + fTmp[3][2] - fTmp[4][2] + fTmp[6][2]; mOut._22 = fTmp[0][3] + fTmp[3][3] - fTmp[4][3] + fTmp[6][3]; // 第二塊 mOut._13 = fTmp[2][0] + fTmp[4][0]; mOut._14 = fTmp[2][1] + fTmp[4][1]; mOut._23 = fTmp[2][2] + fTmp[4][2]; mOut._24 = fTmp[2][3] + fTmp[4][3]; // 第三塊 mOut._31 = fTmp[1][0] + fTmp[3][0]; mOut._32 = fTmp[1][1] + fTmp[3][1]; mOut._41 = fTmp[1][2] + fTmp[3][2]; mOut._42 = fTmp[1][3] + fTmp[3][3]; // 第四塊 mOut._33 = fTmp[0][0] - fTmp[1][0] + fTmp[2][0] + fTmp[5][0]; mOut._34 = fTmp[0][1] - fTmp[1][1] + fTmp[2][1] + fTmp[5][1]; mOut._43 = fTmp[0][2] - fTmp[1][2] + fTmp[2][2] + fTmp[5][2]; mOut._44 = fTmp[0][3] - fTmp[1][3] + fTmp[2][3] + fTmp[5][3]; }

比較
在標準的定義演算法中我們需要進行n * n * n次乘法運算，新演算法中我們需要進行7log2n次乘法，對於最常用的4階矩陣：


原演算法
新演算法

加法次數
48 72(48次加法，24次減法)

乘法次數
64 49

需要額外空間
16 * sizeof(float) 28 * sizeof(float)

新演算法要比原演算法多了24次減法運算，少了15次乘法。但因為浮點乘法的運算速度要遠遠慢於加/減法運算，所以新演算法的整體速度有所提高。

G. 矩陣乘法如何計算詳細步驟!

回答：

此題2行2列矩陣乘以2行3列矩陣。

所得的矩陣是：2行3列矩陣

最後結果為： |1 3 5|

|0 4 6|

拓展資料

1、確認矩陣是否可以相乘。只有第一個矩陣的列的個數等於第二個矩陣的行的個數，這樣的兩個矩陣才能相乘。

圖示的兩個矩陣可以相乘，因為第一個矩陣，矩陣A有3列，而第二個矩陣，矩陣B有3行。

6、檢查相應的數字是否出現在正確的位置。19在左下角，-34在右下角，-2在左上角，-12在右上角。

H. 兩個矩陣相乘怎麼計算

矩陣相乘需要前面矩陣的行數與後面矩陣的列數相同方可相乘。

第一步先將前面矩陣的每一行分別與後面矩陣的列相乘作為結果矩陣的行列。

第二步算出結果即可。

第一個的列數等於第二個的行數，A(3,4) 。B(4,2) 。C=AB，C(3,2)。

(8)矩陣乘法快速演算法擴展閱讀：

矩陣相乘最重要的方法是一般矩陣乘積。只有在第一個矩陣的列數（column）和第二個矩陣的行數（row）相同時才有意義 。

一般單指矩陣乘積時，指的便是一般矩陣乘積。一個m×n的矩陣就是m×n個數排成m行n列的一個數陣。由於它把許多數據緊湊的集中到了一起，所以有時候可以簡便地表示一些復雜的模型。