准备工作 Ready to work

环境 Environment

Anaconda 3 + Python 3.6.5 + Jupyter

模块导入 Module import

import numpy as np
import copy
from numpy.linalg import inv

代数余子式 Algebraic cofactor

定义 Definition

• 定义：在n阶行列式，把$(i,j)$元$a_{ij}$所在的第i行和第j列划去后，留下来的n-1阶行列式叫做$(i,j)$元$a_{ij}$的余子式，记作$M_{ij}$ 。

• $A_{ij}=(-1{)}^{i+j}{M}_{ij}$ 叫做$(i,j)$元$a_{ij}$的代数余子式

• $\mathbf{D}$中$(i,j)$元${\mathbf{a}}_{\mathbf{i}\mathbf{j}}$的余子式和代数余子式分别为：

$${\mathbf{M}}_{\mathbf{i}\mathbf{j}}=\left|\begin{array}{ccccccc}{a}_{11}& a_{12}& \cdots & a_{1j-1}& a_{ij+1}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2j-1}& a_{2j+1}& \cdots & a_{2n}\\ ⋮& ⋮& & ⋮& ⋮& & ⋮\\ a_{i-11}& a_{i-12}& \cdots & a_{i-1j-1}& a_{i-1j+1}& \cdots & a_{i-1n}\\ a_{i+11}& a_{i+12}& \cdots & a_{i+1j-1}& a_{i+1j+1}& \cdots & a_{i+1n}\\ ⋮& ⋮& & ⋮& ⋮& & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mj-1}& a_{mj+1}& \cdots & a_{mn}\end{array}\right|{\mathbf{A}}_{\mathbf{i}\mathbf{j}}=(-1{)}^{\mathbf{i}+\mathbf{j}}{\mathbf{M}}_{\mathbf{i}\mathbf{j}}$$

代码实现 Code

余子式 Cofactor

先求出给定矩阵的余子式，即去除指定的行和列，然后根据公式求出代数余子式。 提供两种实现思路

• 通过遍历实现，但不遍历整个矩阵。

变量说明:

1. M：原始矩阵
2. index：指定元素的索引，长度为2的向量
3. temp：M中的每个行向量
4. det()：求行列式的函数

思路：

1. 创建一个n-1阶的方阵（result）用于存放最后结果

2. 通过遍历向result中按行赋值：

   • 先判断是否为要消去的一行，如果是跳过本次循环

   • 遍历原矩阵并取出其中的行向量

   • 将行向量切片，以index[0]为界限且不包含index[0]

   • 将两个一位矩阵片段拼接并对应放入result中

   • 返回result行列式的值

def cof(M,index):
    result = np.zeros((M.shape[0]-1,M.shape[1]-1))  
    for i in range(M.shape[0]):
        temp = copy.deepcopy(M[i])
        if i==index[0]-1:
            continue
        if i >= index[0]:
            Ri = i-1
        else:
            Ri = i
        result[Ri] = np.append(temp[:index[1]-1],temp[index[1]:])
    return det(result)

• 通过numpy自带方法对矩阵进行重组

1. 首先按照index的两个值作为x、y轴，对矩阵进行切片，将原始矩阵分为左上、右上、左下、右下四个矩阵
2. 利用numpy.concatenate()函数对四个矩阵进行拼接：
   • numpy.concatenate()有两个参数，第一个参数是矩阵列表，是要拼接的矩阵；第二个参数axis，axis=1表示对应行的数组进行拼接，axis=0表示对对应列进行拼接，默认为0
   • 首先将左上、右上两个矩阵按行拼接组成结果矩阵的上半部分
   • 同理求出结果矩阵的下半部分
   • 最后将result的上下两部分按列拼接，返回result的行列式的值

def cof1(M,index):
    zs = M[:index[0]-1,:index[1]-1]
    ys = M[:index[0]-1,index[1]:]
    zx = M[index[0]:,:index[1]-1]
    yx = M[index[0]:,index[1]:]
    s = np.concatenate((zs,ys),axis=1)
    x = np.concatenate((zx,yx),axis=1)
    return det(np.concatenate((s,x),axis=0))

代数余子式 Algebraic cofactor

• 参考公式

def alcof(M,index):
    return pow(-1,index[0]+index[1])*cof(M,index)

伴随矩阵 Adjoint matrix

定义 Definition

• 定义：行列式$\left|\begin{array}{c}A\end{array}\right|$的各个元素的代数余子式$A_{ij}$构成的矩阵。

$$adj(\mathbf{C})=\left[\begin{array}{cccc}{A}_{11}& A_{21}& \cdots & A_{n1}\\ A_{12}& A_{22}& \cdots & A_{n2}\\ ⋮& ⋮& & ⋮\\ A_{1n}& A_{2n}& \cdots & A_{nn}\end{array}\right]{\mathbf{A}}_{\mathbf{i}\mathbf{j}}是{\mathbf{C}}_{\mathbf{i}\mathbf{j}}的代数余子式$$

称为C的伴随矩阵，简称伴随阵，记作$C^{\ast }。$

伴随矩阵满足：

• $A{A}^{\ast }=A^{\ast }A=\left|\begin{array}{c}A\end{array}\right|E$

代码实现 Code

• 分析公式可以看出伴随矩阵的形状与原始矩阵相同，伴随矩阵(i,j)位置上的元是原始矩阵(j,i)位置上元的代数余子式

思路：

1. 创建一个与原始矩阵形状相同的矩阵result
2. 通过向result中填充数据

• 注：矩阵下标从1开始，而在代码中索引均从0开始

def adj(M):
    result = np.zeros((M.shape[0],M.shape[1]))
    for i in range(1,M.shape[0]+1):
        for j in range(1,M.shape[1]+1):
            result[j-1][i-1] = alcof(copy.deepcopy(M),[i,j])
    return result

矩阵的逆 Inverse of matrix

定义 Definition

• 定义：对于n阶矩阵A，如果有一个n阶矩阵B使其满足以下条件，则说矩阵A是可逆的，B是A的逆矩阵，简称逆阵。

$$\mathbf{A}\mathbf{B}=\mathbf{B}\mathbf{A}=\mathbf{E}$$

• A的逆记作${\mathbf{A}}^{-1}$

• 定理1：若矩阵A可逆，则$\left|\begin{array}{c}A\end{array}\right|\ne 0$

• 定理2：若$\left|\begin{array}{c}A\end{array}\right|\ne 0$，则A可逆，且：

$${\mathbf{A}}^{-1}=\frac{1}{\left|\begin{array}{c}A\end{array}\right|}{\mathbf{A}}^{\ast }$$

• 推论：若$\mathbf{A}\mathbf{B}=\mathbf{E}($或$\mathbf{B}\mathbf{A}=\mathbf{E})$，则$\mathbf{B}={\mathbf{A}}^{\ast }$

代码实现 Code

• 根据公式原始矩阵对应行列式的值的倒数乘该矩阵的伴随矩阵

def invmat(M):
    if det(M)!=0:
    	return 1/det(M)*adj(M)
    else:
        print(原始矩阵不能为0)

测试 程序 Test program

• 可以调用numpy.linalg.inv()函数来求得原始矩阵的逆，然后调用自己的函数，看两个输出结果是否相同

from numpy.linalg import inv
M = np.array([[1,2,-1],[2,3,4],[3,1,2]])
print(inv(M))
print(invmat(M))