特殊矩陣與向量相乘的快速演算法

① 一個矩陣乘以一個向量怎麼算

在滿足要求的情況下，按照矩陣乘法的演算法去算即可。

矩陣乘法

兩個矩陣的乘法僅當第一個矩陣A的列數和另一個矩陣B的行數相等時才能定義。如A是m×n矩陣和B是n×p矩陣，它們的乘積C是一個m×p矩陣

4、需要注意的是：矩陣乘法不滿足交換律。

② 矩陣跟向量的乘法怎麼計算

矩陣乘法其實是特殊的向量乘法 因為矩陣可以寫成向量的形式 矩陣C=AB A是m*n矩陣 B是n*s矩陣 C就是m*s矩陣 明白么？ A轉置是3*1 A是1*3 所以二者相乘是3*3矩陣 A是1*3 A轉置是3*1 所以這樣乘出是一個數 （其實數也可以說成是1*1矩陣）

③ 矩陣與向量是怎麼相乘的

其實很簡單，將m按行分塊，將n按列分塊，然後將分完塊的矩陣進行相乘，再找對應元素，就得到所謂的「aij是m的一行與n的一列相乘」；另一方面，將m按列分塊，將n按行分塊，分出的形狀恰好是m=（m1，m2，...，mn),n=
n1
n2
n3
...
nn
這樣分塊相乘，就好像m是一個行向量，n是一個列向量，當然就有所謂「m的一列中的每一個數和n中每一行相乘，然後累加起來，就是最後的矩陣a」。

④ 向量和矩陣的乘法怎麼算

用向量的各個數分別乘矩陣第1列的各個數 之 和 得新向量的第1列的數
同理得其餘數
結果 是:
0.0300 0.0550 0.0850 0.1300 0.1500

滿意請採納^_^

⑤ 2x2矩陣乘法運算是什麼

2x2矩陣的乘法規律:

不滿足交換律，A×B ≠ B×A

滿足結合律，A×(B×C) = (A×B)×C

滿足分配率，A×(B+C) =A×B + A×C

矩陣之間相乘，必須滿足B矩陣列數等於A矩陣行數才能運算，矩陣與矩陣之間的計算可以拆分為矩陣與多個向量的計算再將結果組合，返回的結果為一個列數等於B矩陣、行數等於A矩陣的矩陣。

矩陣的作用：

矩陣是高等代數學中的常見工具，也常見於統計分析等應用數學學科中。[2]在物理學中，矩陣於電路學、力學、光學和量子物理中都有應用；計算機科學中，三維動畫製作也需要用到矩陣。 矩陣的運算是數值分析領域的重要問題。

將矩陣分解為簡單矩陣的組合可以在理論和實際應用上簡化矩陣的運算。對一些應用廣泛而形式特殊的矩陣，例如稀疏矩陣和准對角矩陣，有特定的快速運算演算法。

關於矩陣相關理論的發展和應用，請參考《矩陣理論》。在天體物理、量子力學等領域，也會出現無窮維的矩陣，是矩陣的一種推廣。

數值分析的主要分支致力於開發矩陣計算的有效演算法，這是一個已持續幾個世紀以來的課題，是一個不斷擴大的研究領域。 矩陣分解方法簡化了理論和實際的計算。

針對特定矩陣結構（如稀疏矩陣和近角矩陣）定製的演算法在有限元方法和其他計算中加快了計算。 無限矩陣發生在行星理論和原子理論中。 無限矩陣的一個簡單例子是代表一個函數的泰勒級數的導數運算元的矩陣。

以上內容參考：網路-矩陣

⑥ 向量乘矩陣是如何計算的

向量是一個一行n列（或n行一列）的特殊矩陣，適用於矩陣的運算規則。行向量乘以矩陣的話用行向量乘以矩陣的每一列，矩陣乘以列向量的話用矩陣的每一行乘以列向量

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

演算法介紹
矩陣相乘在進行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次乘法。但因為浮點乘法的運算速度要遠遠慢於加/減法運算，所以新演算法的整體速度有所提高。

⑧ 矩陣與向量乘法

首先矩陣和向量是不同的。矩陣就是一堆數，向量是有方向有大小的量。
矩陣可以與數相乘，也可以與矩陣相乘，應為他本身就是數。它的成法規則是，如AB只要A的列數等於B的行數就可以相乘了。所以列向量是可以與行向量相乘的。
而向量的成法則沒什麼必要的條件。它的結果是一個數。
如ab則ab=｜a｜*｜b｜*cosθ 。 θ 是兩個向量的夾角。｜a｜和｜b｜就是a和b的模也就是他們的大小。

A的轉置記做A』或者A加上T的上標（不好意我打不出來）。

A』= 1 2 1豎著排列。
A*A』等於
121
242
121

A』*A等於
6

上面的回答基本都正確，建議可以找本線性代數看一下就可以了。

⑨ 矩陣和向量相乘怎麼算

把向量當成一維的矩陣乘,但是要注意矩陣乘法的規則.要是矩陣點乘的話就是對應元素相乘就好了.