线性代数应用

1.求逆矩阵

np.linalg.inv(A)

A=np.mat(np.array([[0,1,2],
                   [1,0,3],
                   [4,-3,8]]))
print("A:\n",A)-------------------->A:
                                     [[ 0  1  2]
                                     [ 1  0  3]
                                     [ 4 -3  8]]
A_=np.linalg.inv(A)
print("A的逆矩阵：\n",A_)----------->A的逆矩阵：
                                     [[-4.5  7.  -1.5]
                                     [-2.   4.  -1. ]
                                     [ 1.5 -2.   0.5]]
#验证A*A_结果是否为一个单位矩阵
print(A*A_)------------------------>[[1. 0. 0.]
                                     [0. 1. 0.]
                                     [0. 0. 1.]]

2.求解三元一次方程组

result=np.linalg.solve(A,b)

x-2y+z=0
2y-8z=8
-4x+5y+9z=-9

A=np.mat("1 -2 1;0 2 -8;-4 5 9")
print("方程组系数：\n",A)----------->方程组系数：
                                             [[ 1 -2  1]
                                              [ 0  2 -8]
                                              [-4  5  9]]
b=np.array([0,8,-9])
# b=np.mat("0 8 -9")
print("常数项：\n",b)-------------->常数项：
                                              [ 0  8 -9]

#调用numpy的solve方法求解
result=np.linalg.solve(A,b)
print("x={},y={},z={}".format(result[0],result[1],result[2]))
                    --------------->x=29.0,y=16.0,z=3.0

3.求特征值和特征向量

特征值（eigenvalue）即方程 Ax = ax 的根，是一个标量。其中，A 是一
个二维矩阵，x 是一个一维向量。特征向量（eigenvector）是关于特征值的
向量。在 numpy.linalg 模块中， eigvals 函数可以计算矩阵的特征值，而
eig 函数可以返回一个包含特征值和对应的特征向量的元组。

vector=np.mat("3 -2;1 0")
print("vector:\n",vector)------------->vector:
                                             [[ 3 -2]
                                              [ 1  0]]
eigenvalues,eigvector=np.linalg.eig(vector)
print("向量的特征值:\n",eigenvalues)--->向量的特征值:
                                              [2. 1.]
print("特征向量：\n",eigvector)-------->特征向量：
                                             [[0.89442719 0.70710678]
                                              [0.4472136  0.70710678]]

4.调用numpy中的svd方法对矩阵进行SVD(奇异值分解)

调用numpy中的svd方法对矩阵进行SVD(奇异值分解)
SVD是一种因子分解运算，将一个矩阵分解为3个矩阵的乘积在numpy.linalg模块
中的svd函数可以对矩阵进行奇异值分解。该函数返回3个矩阵—— U 、
Sigma和 V ，其中 U 和 V 是正交矩阵，Sigma包含输入矩阵的奇异值。

vector=np.mat("4 11 14;8 7 -2")
print(vector)------------------------>[[ 4 11 14]
                                       [ 8  7 -2]]


U,Sigma,V=np.linalg.svd(vector,full_matrices=False)
print("U:\n",U)---------------------->U:
                                      [[-0.9486833  -0.31622777]
                                       [-0.31622777  0.9486833 ]]

print("Sigma:\n",Sigma)-------------->Sigma:
                                       [18.97366596  9.48683298]

print("V:\n",V)---------------------->V:
                                      [[-0.33333333 -0.66666667 -0.66666667]
                                       [ 0.66666667  0.33333333 -0.66666667]]

#将svd分解出的值相乘
print("vector:\n",U*np.diag(Sigma)*V)
               ---------------------->vector:
                                      [[ 4. 11. 14.]
                                       [ 8.  7. -2.]]

5.求矩阵的行列式

vector=np.mat("3 4;5 6 ")
print(vector)------------------------>[[3 4]
                                       [5 6]]
value=np.linalg.det(vector)
print("矩阵行列式的值：\n",value)------>矩阵行列式的值：-2.0000000000000004