快捷搜索:
来自 67677新澳门手机版 2019-11-05 16:49 的文章
当前位置: 67677新澳门手机版 > 67677新澳门手机版 > 正文

矩阵专栏,在Shader之前_基础数学

2.3.5.单位矩阵¶

单位矩阵 :单位矩阵是个方阵(行列相等卡塔 尔(阿拉伯语:قطر‎,从左上角到右下角的对角线(称为主对角线卡塔 尔(阿拉伯语:قطر‎上的要素均为1。其余全都为0,eg:

$ begin{bmatrix} 1&0&0 \ 0&1&0 \ 0&0&1 end{bmatrix} $

任何矩阵 x 单位矩阵 都等于其本身 (反过来也相符(那个和1×a=a×1四个道理卡塔尔卡塔尔国

In [31]:

# 定义一个2行的单位矩阵(列默认和行一致)
# np.eye(rows,columns=rows)
np.eye(2)

Out[31]:

array([[1., 0.],
       [0., 1.]])

In [32]:

################ 验证扩展 ################

In [33]:

# 可以指定类型
B = np.eye(4,dtype=int)

print(B)

 

[[1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]

In [34]:

print(A)

 

[[3 5 2 3]
 [7 2 9 6]
 [5 1 7 6]
 [1 2 8 4]]

In [35]:

# 任何矩阵 x 单位矩阵 都等于其本身
A.dot(B)

Out[35]:

array([[3, 5, 2, 3],
       [7, 2, 9, 6],
       [5, 1, 7, 6],
       [1, 2, 8, 4]])

In [36]:

# 反过来也一样(这个和1*a=a*1一个道理)
B.dot(A)

Out[36]:

array([[3, 5, 2, 3],
       [7, 2, 9, 6],
       [5, 1, 7, 6],
       [1, 2, 8, 4]])

 

向量

向量首先要跟标量区分:向量具备可行性和尺寸等概念,而标量唯有大小。在Unity中常用的向量有法线、切线等。

在表示方式上,向量能够用一个意气风发维数组代表,例如:
![][1]
[1]:http://latex.codecogs.com/png.latex?a=begin{bmatrix}1&2&3end{bmatrix}

![][2]
[2]:http://latex.codecogs.com/png.latex?a=begin{bmatrix}123end{bmatrix}
横向书写的名称叫行向量,竖向书写的名字为列向量,向量中的每三个分占的额数对应于其n维空间中的分量,上例中分量为x、y、z,至于在运用时是用行依然列,要依附实际意况来规定。(前边会提到卡塔 尔(阿拉伯语:قطر‎
而在物理中,向量具备其实际意义:举例上述的a向量,表示由一个点到此外贰个点位移,上式中,表示点A向x方向活动1个单位,y方向移动2个单位,z方向移动3个单位达到点B。(注意,在坐标系中,位移未有现实的地方,可以在随便地点表示,只表示位移量和大势卡塔尔国

2.1.矩阵的概念¶

矩阵:是一个如约长方阵列排列的复数或实数集结。

深入显出讲正是:把数排成m行n列后,然后用中括号把它们括住,这种样式的三结合就是矩阵了~ eg:

$begin{bmatrix} &a_{11}&a_{12}&a_{13}&...&a_{1n} \ &a_{21}&a_{22}&a_{23}&...&a_{2n} \ &a_{31}&a_{32}&a_{33}&...&a_{3n} \ &vdots&vdots&vdots&ddots&vdots\ &a_{m1}&a_{m2}&a_{m3}&...&a_{mn} \ end{bmatrix}$

比方下面那些示例正是一个m × n的矩阵(m行n列的矩阵卡塔 尔(英语:State of Qatar),借使m=n那么就叫做n阶方阵,eg:

$begin{bmatrix} 1&2&3 \ 4&5&6 \ 7&8&9 end{bmatrix}$

本条便是3阶方阵


假定回到中学,老师确定都以通过二次方程组来引进矩阵(逆天的导师是这么讲的卡塔 尔(英语:State of Qatar):

$begin{cases}x_1 x_2=-1\2x_1-x_2=4\3x_1 5x_2=-7\end{cases}$ ==> $begin{bmatrix}1&1\2&-1\3&5end{bmatrix}begin{bmatrix}x_1\x_2end{bmatrix}=begin{bmatrix}-1\4\-7end{bmatrix}$

假使您方程组都记不清怎么解的话...好呢依旧说下呢:“比如那题,能够先把x2移到左边手,那样x1就非常叁个表达式了(x1=-x2-1卡塔 尔(阿拉伯语:قطر‎,然后带入第贰个说明式就能够解出x1和x2了,一回的莫过于七个表明式就能够解出了,剩下的您能够把值带进去验证一下”

坐标系

先是要讲的是坐标系,在3D中,坐标系类型有为数不菲,相比较关键的是3D坐标系,数不胜数的分三种:左手坐标系和侧面坐标系,首要差别是Z轴的取向(大家定义X轴暗中认可正方向为右,Y轴暗许正方向为上卡塔 尔(阿拉伯语:قطر‎,左臂系Z轴正方向为指向显示屏中间,右臂系Z轴正方向为指向荧屏表面:

67677新澳门手机版 1

左边手系 (图截自《3D数学根基:图形与游戏开采》卡塔尔国

67677新澳门手机版 2

左边系 (图截自《3D数学底蕴:图形与游戏支付》卡塔尔

Ps:在Unity中,默许使用的是左边坐标系(录像机的观看比赛空间(以录像机为原点的坐标系卡塔尔国除此而外卡塔 尔(英语:State of Qatar)。

在叁个空中中,有了坐标系的留存,就足以规定空间中物体的具体位置。

2.2.矩阵的演算(含幂运算卡塔尔国¶

向量点乘

点乘形式:
![][6]
[6]:http://latex.codecogs.com/png.latex?begin{bmatrix}a_1a_2a_3end{bmatrix}.begin{bmatrix}b_1b_2b_3end{bmatrix}=a_1b_1 a_2b_2 a_3b_3
几何点乘公式:
![][7]
[7]:http://latex.codecogs.com/png.latex?acdot{b}=left|aright|*left|bright|astcostheta
其几何意义为向量a在向量b上的阴影(当夹角超过90°时结果为负值卡塔 尔(英语:State of Qatar)

67677新澳门手机版 3

点乘 (图截自《3D数学幼功:图形与娱乐支付》卡塔尔国

向量点乘结果为三个标量。

强盛类别:伪逆矩阵¶

非方阵能够求 伪逆矩阵 AXA=A,XAX=X

认清矩阵是或不是可逆:

$$detbegin{bmatrix}a_{11}&a_{12} \a_{21}&a_{22}end{bmatrix}=a_67677新澳门手机版 ,{11}a_{12}-a_{12}a_{21}\detbegin{bmatrix}a_{11}&a_{12}&a_{13} \a_{21}&a_{22}&a_{23}\a_{31}&a_{32}&a_{33}end{bmatrix}=a_{11}a_{22}a_{33} a_{12}a_{23}a_{31} a_{13}a_{21}a_{32}-a_{13}a_{22}a_{31}-a_{12}a_{21}a_{33}-a_{11}a_{23}a_{32}$$

艺术非常多(例如还足以经过余子式),公式其实有规律,你能够先找找下(给个提示):

正负
a11a22
a12a21 -
正负
a11a22a33
a11a23a32 -
a12a21a33 -
a12a23a31
a13a21a32
a13a22a31 -

次第比较简单:np.linalg.det(A)

In [46]:

A = np.array([[7, 3, 6],[5, 3, 1]])

print(A)

 

[[7 3 6]
 [5 3 1]]

In [47]:

# 不等于0就是可逆
np.linalg.det(A)

 

---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-47-2ce8e7bdf499> in <module>()
      1 # 不等于0就是可逆
----> 2np.linalg.det(A)

~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in det(a)
   1869     a = asarray(a)
   1870     _assertRankAtLeast2(a)
-> 1871_assertNdSquareness(a)
   1872     t, result_t = _commonType(a)
   1873     signature = 'D->D' if isComplexType(t) else 'd->d'

~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in _assertNdSquareness(*arrays)
    209     for a in arrays:
    210         if max(a.shape[-2:]) != min(a.shape[-2:]):
--> 211raise LinAlgError('Last 2 dimensions of the array must be square')
    212 
    213 def _assertFinite(*arrays):

LinAlgError: Last 2 dimensions of the array must be square

In [48]:

# 必须是方阵的验证
np.linalg.inv(A)

 

---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-48-0af3c81a492f> in <module>()
      1 # 必须是方阵的验证
----> 2np.linalg.inv(A)

~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in inv(a)
    521     a, wrap = _makearray(a)
    522     _assertRankAtLeast2(a)
--> 523_assertNdSquareness(a)
    524     t, result_t = _commonType(a)
    525 

~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in _assertNdSquareness(*arrays)
    209     for a in arrays:
    210         if max(a.shape[-2:]) != min(a.shape[-2:]):
--> 211raise LinAlgError('Last 2 dimensions of the array must be square')
    212 
    213 def _assertFinite(*arrays):

LinAlgError: Last 2 dimensions of the array must be square

In [49]:

# 有时候还是需要求逆矩阵
# 那就可以求它的伪逆矩阵
X = np.linalg.pinv(A)

print(X)

 

[[-0.00632911  0.15189873]
 [-0.05696203  0.16708861]
 [ 0.20253165 -0.26075949]]

In [50]:

# A*X*A=A
A.dot(X).dot(A)

Out[50]:

array([[7., 3., 6.],
       [5., 3., 1.]])

In [51]:

# X*A*X=X
X.dot(A).dot(X)

Out[51]:

array([[-0.00632911,  0.15189873],
       [-0.05696203,  0.16708861],
       [ 0.20253165, -0.26075949]])

In [52]:

################ 简单说下mat ################

In [53]:

# 创建一个矩阵
A = np.mat([[3,2],[1,2]])

print(A)
type(A)

 

[[3 2]
 [1 2]]

Out[53]:

numpy.matrixlib.defmatrix.matrix

In [54]:

# 求它的逆矩阵
A.I

Out[54]:

matrix([[ 0.5 , -0.5 ],
        [-0.25,  0.75]])

In [55]:

# A^T
A.T

Out[55]:

matrix([[3, 1],
        [2, 2]])

In [56]:

# *默认就是矩阵乘法
A * A

Out[56]:

matrix([[11, 10],
        [ 5,  6]])

In [57]:

# 更多自己查看下帮助文档把,用法和array基本上一样,
# 我这边只是简单提一下,怕你们不去看(所有和矩阵相关的东西,里面都有封装,很方便)
np.mat?

向量运算

向量的演算很简短,其实正是逐条分类的相加减。
以加法为例(减法相似卡塔尔:
![][5]
[5]:http://latex.codecogs.com/png.latex?begin{bmatrix}123end{bmatrix} begin{bmatrix}321end{bmatrix}=begin{bmatrix}1 32 23 1end{bmatrix}=begin{bmatrix}444end{bmatrix}

2.4.2.二阶方阵公式¶

假设只是2阶方阵,有更简便的公式(只好2阶使用,而消元法不受限定卡塔 尔(英语:State of Qatar)矩阵是不是可逆就看分母是还是不是为0

$large{begin{bmatrix}a_{11}&a_{12} \a_{21}&a_{22}end{bmatrix}=frac{1}{a_{11}a_{22}-a_{12}a_{21}}begin{bmatrix}a_{22}&-a_{12} \-a_{21}&a_{11}end{bmatrix}}$

比如求$begin{bmatrix}3&2 \1&2end{bmatrix}^{-1}$:

$frac{1}{3×2-2×1}begin{bmatrix}2&-2 \-1&3end{bmatrix}=begin{bmatrix}frac{1}{2}&-frac{1}{2} \-frac{1}{4}&frac{3}{4} end{bmatrix}$

大家能够得出结论:
  • 方阵的行能被分解为坐标系的基向量
  • 向量乘以二个矩阵,将从原坐标系转换来新坐标系
  • 从原坐标系到这几个基向量定义的新坐标系的退换是生龙活虎种线性别变化换。线性别变化换保持直线和平行线,但角度、长度、面积或体量恐怕会被修改。

 

矩阵的几何意义

矩阵常用与坐标系的转变。
先交由精通:矩阵中的每大器晚成行都能解释为转移后的基向量(基向量:坐标轴向量,在三个维度空间中维X,Y,Z轴,当长度为1时称为标准基向量卡塔尔。
先用2维坐标为例:
对转移矩阵:
![][18]
[18]:http://latex.codecogs.com/png.latex?M=begin{bmatrix}2&1-1&2end{bmatrix}

67677新澳门手机版 4

坐标轴转换 (图截自《3D数学基本功:图形与游戏支付》卡塔 尔(阿拉伯语:قطر‎

如上航海用体育场地所示:x轴从品位单位长度转造成点p(2,1),y轴从垂直单位长度调换来点q(-1,2);也正是说,该矩阵所完结的功用是让坐标系旋转角度并比例放大,换个说法,坐标轴从原来的坐标系调换来了新的坐标系了。

67677新澳门手机版 5

更动职能 (图截自《3D数学功底:图形与游乐开拓》卡塔 尔(英语:State of Qatar)

上航海用教室能够看来转变职能:旋转并加大

上面看看3维坐标的功用:
3D转换矩阵:
![][19]
[19]:http://latex.codecogs.com/png.latex?begin{bmatrix}0.707&-0.707&01.250&1.250&0\0&0&1end{bmatrix}

67677新澳门手机版 6

原效果 (图截自《3D数学底工:图形与游戏开辟》卡塔 尔(英语:State of Qatar)

67677新澳门手机版 7

转移后 (图截自《3D数学基本功:图形与游戏支付》卡塔 尔(英语:State of Qatar)

能够见到,转换矩阵中每生机勃勃行对应转换X,Y,Z轴,该调换矩阵的功用为沿Z轴旋转45°,并拓宽不法则缩放。

2.3.3.上三角矩阵和下三角矩阵¶

上三角矩阵 :主对角线以下都以零的方阵

$begin{bmatrix} 2&9&4&7 \ 0&7&3&3 \ 0&0&6&1 \ 0&0&0&1 end{bmatrix}$

下三角矩阵 :主对角线以上都是零的方阵

$begin{bmatrix} 2&0&0&0 \ 3&7&0&0 \ 5&6&7&0 \ 1&2&3&4 end{bmatrix}$

性情(行列式后边会说卡塔 尔(英语:State of Qatar)

  1. 上(下卡塔 尔(阿拉伯语:قطر‎三角矩阵的行列式为对角线成分相乘
  2. 上(下卡塔 尔(英语:State of Qatar)三角矩阵乘以周密后也是上(下卡塔尔三角矩阵
  3. 上(下卡塔尔国三角矩阵间的加减法和乘法运算的结果仍然是上(下卡塔尔三角矩阵
  4. 上(下卡塔 尔(阿拉伯语:قطر‎三角矩阵的逆矩阵也仍是上(下卡塔尔国三角矩阵

In [21]:

# 创建一个5行4列矩阵
A = np.random.randint(10,size=(4,4))

print(A)

 

[[3 5 2 3]
 [7 2 9 6]
 [5 1 7 6]
 [1 2 8 4]]

In [22]:

# 上三角
np.triu(A)

Out[22]:

array([[3, 5, 2, 3],
       [0, 2, 9, 6],
       [0, 0, 7, 6],
       [0, 0, 0, 4]])

In [23]:

# 下三角
np.tril(A)

Out[23]:

array([[3, 0, 0, 0],
       [7, 2, 0, 0],
       [5, 1, 7, 0],
       [1, 2, 8, 4]])

In [24]:

# 验证一下最后一个性质
# 三角矩阵的逆矩阵也仍然是三角矩阵
print(np.triu(A).T)
print('-'*5)
print(np.tril(A).T)

 

[[3 0 0 0]
 [5 2 0 0]
 [2 9 7 0]
 [3 6 6 4]]
-----
[[3 7 5 1]
 [0 2 1 2]
 [0 0 7 8]
 [0 0 0 4]]

 

转置矩阵

转置矩阵即为沿对角线翻转的矩阵:
![][13]
[13]:http://latex.codecogs.com/png.latex?{begin{bmatrix}1&2&34&5&67&8&9end{bmatrix}}^T=begin{bmatrix}1&4&72&5&83&6&9end{bmatrix}
对此向量,行向量变为列向量为:
![][14]
[14]:http://latex.codecogs.com/png.latex?{begin{bmatrix}1&2&3end{bmatrix}}^T=begin{bmatrix}123end{bmatrix}
转置矩阵的习性:
![][21]
[21]:http://latex.codecogs.com/png.latex?(MT)T=M,(AB)T=BTA^T

2.3.3.转置矩阵¶

转置矩阵 :将矩阵的行列沟通获得的新矩阵(行列式不改变)

m行×n列的矩阵行和列交换后就改成了n行×m列的矩阵,eg:3行×2列 ==> 2行×3列

$begin{bmatrix}1&2 \3&4 \5&6end{bmatrix}^T ==> begin{bmatrix}1&3&5 \2&4&6end{bmatrix}$

矩阵的转置满意分配律:

$(A B)^T = A^T B^T$

$(AB)^T = B^TA^T$

再一次提示:四个矩阵的乘法仅当第八个矩阵A的列数(column)和另多个矩阵B的行数(row)相等才得以开展总计

In [12]:

A = np.arange(6).reshape((2,3))

print(A)

 

[[0 1 2]
 [3 4 5]]

In [13]:

# 转置矩阵(行列互换)
A.T

Out[13]:

array([[0, 3],
       [1, 4],
       [2, 5]])

In [14]:

B = np.random.randint(10,size=(2,3))

print(B)

 

[[4 4 7]
 [5 3 9]]

In [15]:

################ 验证系列 ################

In [16]:

# 验证一下(A B)^T=A^T B^T
print(A.T   B.T)
print("-"*5)
print((A B).T)

 

[[ 4  8]
 [ 5  7]
 [ 9 14]]
-----
[[ 4  8]
 [ 5  7]
 [ 9 14]]

In [17]:

# 验证一下(A B)^T=A^T B^T
# 其实也再一次验证了,Numpy运算符默认是对每一个元素的操作
(A B).T == A.T   B.T

Out[17]:

array([[ True,  True],
       [ True,  True],
       [ True,  True]])

In [18]:

################ 验证系列 ################

In [19]:

# 把A变成3*2的矩阵,不够元素用0补
# reshape:有返回值,不对原始多维数组进行修改
# resize:无返回值,会对原始多维数组进行修改
A.resize(3,2)

print(A)
print(B)

 

[[0 1]
 [2 3]
 [4 5]]
[[4 4 7]
 [5 3 9]]

In [20]:

# 验证(AB)^T=B^T×A^T
print((A.dot(B)).T)
print("-"*5)
print((B.T).dot(A.T))

 

[[ 5 23 41]
 [ 3 17 31]
 [ 9 41 73]]
-----
[[ 5 23 41]
 [ 3 17 31]
 [ 9 41 73]]

 

正交矩阵

正交矩阵是其与其转置矩阵的乘积是单位矩阵的矩阵,即:
![][23]
[23]:http://latex.codecogs.com/png.latex?MMT=MTM=I
世家能够对照逆矩阵的性质
![][24]
[24]:http://latex.codecogs.com/png.latex?MM{-1}=M{-1}M=I
小编们得以摄取三个很有用的消息:
假如多少个矩阵是正交矩阵,大家能够透过求转置的点子求出其逆矩阵,那将能够大大少之甚少运算量
正如名字相像,这种矩阵的3个基向量分别是正交关系,即互相垂直,由于
![][25]
[25]:http://latex.codecogs.com/png.latex?MM^T=begin{bmatrix}-&c_1&--&c_2&--&c_3&-end{bmatrix}begin{bmatrix}|&|&|c_1&c_2&c_3|&|&|end{bmatrix}=begin{bmatrix}c_1c_1&c_1c_2&c_1c_3c_2c_1&c_2c_2&c_2c_3c_3c_1&c_3c_2&c_3c_3end{bmatrix}=begin{bmatrix}1&0&0\0&1&0\0&0&1end{bmatrix}
能够见见矩阵的每风流罗曼蒂克行c1,c2,c3必得为单位矢量,只有如此点乘的结果本领是1。
也便是说,大家有不会细小略的章程来了然一个矩阵是还是不是为正交矩阵,即
c1,c2,c3均为单位矢量况且互相垂直


边忙边写写了一些天,终于写好了。。。数学真是生龙活虎财美妙的课程。

2.2.4.幂乘、幂运算¶

幂乘比较简单,正是每一个成分开平方,不显明是方阵

非得是方阵手艺开展幂运算,比如A²=A×A(矩阵相乘前提:第一个矩阵A的行=第二个矩阵A的列==>方阵

In [22]:

print(A)
print("-"*5)
print(C)

 

[[1 2]
 [3 4]]
-----
[[0 1 2]
 [3 4 5]]

In [23]:

# 幂乘(每个元素开平方) 
np.power(A,2) # 使用 A**2也一样

Out[23]:

array([[ 1,  4],
       [ 9, 16]])

In [24]:

# 幂乘(不一定是方阵) 
np.power(C,2)

Out[24]:

array([[ 0,  1,  4],
       [ 9, 16, 25]])

In [25]:

################ 方阵幂运算 ################

In [26]:

# A*A*A
np.linalg.matrix_power(A,3)

Out[26]:

array([[ 37,  54],
       [ 81, 118]])

In [27]:

# 不是方阵就over
np.linalg.matrix_power(C,3)

 

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-27-73f04ef7b54c> in <module>()
      1 # 不是方阵就over
----> 2np.linalg.matrix_power(C,3)

~/anaconda3/lib/python3.6/site-packages/numpy/matrixlib/defmatrix.py in matrix_power(M, n)
    137     M = asanyarray(M)
    138     if M.ndim != 2 or M.shape[0] != M.shape[1]:
--> 139raise ValueError("input must be a square array")
    140     if not issubdtype(type(n), N.integer):
    141         raise TypeError("exponent must be an integer")

ValueError: input must be a square array

 

来个小结 扩充

矩阵的加法运算满足交流律:A B = B A

矩阵的乘法满意结合律和对矩阵加法的分配律:

结合律:(AB)C = A(BC)

左分配律:(A B)C = AC BC

右分配律:C(A B) = CA CB

矩阵的乘法与数乘运算之间也满意相通结合律的准则;与转置之间则满足倒置的

分配律:c(A B) = cA cB

结合律:c(AB) = (cA)B = A(cB)

矩阵乘法不满意沟通律 平日的话,矩阵A及B的乘积AB存在,但BA不必然存在,固然存在,大好些个时候AB ≠ BA


向量与矩阵的乘法

![][16]
[16]:http://latex.codecogs.com/png.latex?begin{bmatrix}x&y&zend{bmatrix}begin{bmatrix}m_{11}&m_{12}&m_{13}m_{21}&m_{22}&m_{23}m_{31}&m_{32}&m_{33}end{bmatrix}=begin{bmatrix}xm_{11} ym_{21} zm_{31}&xm_{12} ym_{22} zm_{32}&xm_{13} ym_{23} zm_{33}end{bmatrix}
![][17]
[17]:http://latex.codecogs.com/png.latex?begin{bmatrix}m_{11}&m_{12}&m_{13}m_{21}&m_{22}&m_{23}m_{31}&m_{32}&m_{33}end{bmatrix}begin{bmatrix}xyzend{bmatrix}=begin{bmatrix}xm_{11} ym_{12} zm_{13}xm_{21} ym_{22} zm_{23}xm_{31} ym_{32} zm_{33}end{bmatrix}
由上可以预知,行向量左乘矩阵,结果是行向量;列向量右乘矩阵,结果是列向量。
(Ps:在Unity中,常把向量方在矩阵的右侧,即选用列向量实行演算。此种情形下,大家阅读的逐个应该为从右往左阅读,即:中职篮v为对向量v先进行A矩阵调换,再张开B,末了进行C矩阵调换。矩阵转换请以往看卡塔尔

2.3.4.对角矩阵¶

对角矩阵 :主对角线之外的成分皆为0的方阵 (单位矩阵归属对角矩阵中的生机勃勃种卡塔 尔(英语:State of Qatar)

$begin{bmatrix}0&0&0 \0&0&0 \0&0&0end{bmatrix} begin{bmatrix}1&0&0 \0&1&0 \0&0&1end{bmatrix} begin{bmatrix}2&0&0 \0&2&0 \0&0&2end{bmatrix} begin{bmatrix}3&0&0 \0&9&0 \0&0&6end{bmatrix}$

闻一知十:对角矩阵的运算包罗和、差运算、数乘运算、同阶对角阵的乘积运算,且结果仍然是对角阵

何况风趣的是:对角矩阵的矩阵幂运算等于其对应成分的幂运算

$begin{bmatrix}3&0&0 \0&9&0 \0&0&6end{bmatrix}^n = begin{bmatrix}3^n&0&0 \0&9^n&0 \0&0&6^nend{bmatrix}$

In [25]:

# 简单创建
np.diag([3,9,6])

Out[25]:

array([[3, 0, 0],
       [0, 9, 0],
       [0, 0, 6]])

In [26]:

np.diag([2,2,2])

Out[26]:

array([[2, 0, 0],
       [0, 2, 0],
       [0, 0, 2]])

In [27]:

################ 验证系列 ################

In [28]:

# np.diag?
print(A)

# 获取对角元素,然后再生成对角矩阵
B = np.diag(A.diagonal()) #或者 np.diag(np.diag(A))

print(B)

 

[[3 5 2 3]
 [7 2 9 6]
 [5 1 7 6]
 [1 2 8 4]]
[[3 0 0 0]
 [0 2 0 0]
 [0 0 7 0]
 [0 0 0 4]]

In [29]:

B.dot(B).dot(B)

Out[29]:

array([[ 27,   0,   0,   0],
       [  0,   8,   0,   0],
       [  0,   0, 343,   0],
       [  0,   0,   0,  64]])

In [30]:

# 对角矩阵的矩阵幂运算等于其对应元素的幂运算
B**3

Out[30]:

array([[ 27,   0,   0,   0],
       [  0,   8,   0,   0],
       [  0,   0, 343,   0],
       [  0,   0,   0,  64]])

 

本文章面向的对象是有3D数学根底可是出于长日子没接触变生分,或对少数知识点掌握尚十分的人群。

本文由67677新澳门手机版发布于67677新澳门手机版,转载请注明出处:矩阵专栏,在Shader之前_基础数学

关键词: