特殊矩阵与向量相乘的快速算法

① 一个矩阵乘以一个向量怎么算

在满足要求的情况下，按照矩阵乘法的算法去算即可。

矩阵乘法

两个矩阵的乘法仅当第一个矩阵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

上面的回答基本都正确，建议可以找本线性代数看一下就可以了。

⑨ 矩阵和向量相乘怎么算

把向量当成一维的矩阵乘,但是要注意矩阵乘法的规则.要是矩阵点乘的话就是对应元素相乘就好了.