八.Linalg模块
1.基础函数
(1)关于矩阵:
求矩阵的行列式:scipy.linalg.det(<a>[,overwrite_a=False,check_finite=True])
#参数说明:check_finite同scipy.linalg.matmul_toeplitz()
a:指定矩阵;为N×N array-like
overwrite_a:指定是否允许重写<a>中的数据;为bool
#若为True,可能带来性能上的提升
######################################################################################################################
求逆矩阵:scipy.linalg.inv(<a>[,overwrite_a=False,check_finite=True])
#参数说明:check_finite同scipy.linalg.matmul_toeplitz(),overwrite_a同scipy.linalg.det()
a:指定原矩阵;为N×N array-like
######################################################################################################################
求"Khatri-Rao积"(KR积;Khatri-Rao Product):[<A>=]scipy.linalg.khatri_rao(<a>,<b>)
#参数说明:
a,b:指定矩阵;分别为M×K array-like/N×K array-like
A:返回结果;为(M*N)×K ndarray
######################################################################################################################
求"克罗内克积"(Kronecker Product):[<A>=]scipy.linalg.kron(<a>,<b>)
#参数说明:
a,b:指定矩阵;分别为M×N array-like/P×Q array-like
A:返回结果;为(M*P)×(N*Q) ndarray
######################################################################################################################
求"托普利兹矩阵"(Toeplitz Matrix)与"稠密矩阵"(Dense Matrix)的乘积:scipy.linalg.matmul_toeplitz(<c_or_cr>,<x>[,check_finite=False,workers=None])
#通过FFT实现
#参数说明:
c_or_cr:指定托普利兹矩阵;为<c>/(<c>,<r>),<c>/<r>均为array-like,默认<r>=conjugate(<c>)
#<c>为托普利兹矩阵的首列,<r>为托普利兹矩阵的首行
x:指定稠密矩阵;为N×M array-like
check_finite:指定是否检查<a>仅包含有限值;为bool
#若为False,则可能带来性能上的提升;但若矩阵确实包含Inf/NaN,可能导致问题
workers:指定最大并行计算子任务数;为int(负值表示由os.cpu_count()决定)
######################################################################################################################
scipy.linalg.matrix_balance(<A>[,permute=True,scale=True,separate=False,overwrite_a=False])
######################################################################################################################
求向量/矩阵的范数(Norm):scipy.linalg.norm(<a>[,ord=None,axis=None,keepdims=False,check_finite=True])
#参数说明:check_finite同scipy.linalg.matmul_toeplitz()
a:指定向量/矩阵;为M×N array-like
#若axis=None,则<a>应为1D array-like/2D array-like
ord:指定要计算的范数;为int≠0/±Inf/"fro"/None
#ord norm for matrices norm for vectors
#None Frobenius norm 2-norm
#"fro" Frobenius norm -
#Inf max(sum(abs(<x>),axis=1)) max(abs(<x>))
#-Inf min(sum(abs(<x>),axis=1)) min(abs(<x>))
#0 - sum(<x>!=0)
#1 max(sum(abs(<x>),axis=0)) sum(abs(<x>)**ord)**(1./ord)
#-1 min(sum(abs(<x>),axis=0)) sum(abs(<x>)**ord)**(1./ord)
#2 2-norm (largest sing. value) sum(abs(<x>)**ord)**(1./ord)
#-2 smallest singular value sum(abs(<x>)**ord)**(1./ord)
#other - sum(abs(<x>)**ord)**(1./ord)
axis,keepdims:指定传递给numpy.linalg.norm()的axis/keepdims参数的值
######################################################################################################################
求解"正交普鲁克问题"(Orthogonal Procrustes Problem):[<R>,<scale>=]scipy.linalg.orthogonal_procrustes(<A>,<B>[,check_finite=True])
#参数说明:check_finite同scipy.linalg.matmul_toeplitz()
A,B:指定矩阵;均为M×N array-like
R:返回结果;为N×N ndarray
scale:返回A.T*B的所有奇异值的和;为float
######################################################################################################################
求"穆尔-彭罗斯伪逆矩阵"(Moore-Penrose Pseudo-Inverse of Matrix):[<B>,<rank>=]scipy.linalg.pinv(<a>[,cond=None,rcond=None,return_rank=False,check_finite=True])
#通过最小二乘法实现
求穆尔-彭罗斯伪逆矩阵:[<B>,<rank>=]scipy.linalg.pinv2(<a>[,cond=None,rcond=None,return_rank=False,check_finite=True])
#通过SVD实现
求埃尔米特矩阵的穆尔-彭罗斯伪逆矩阵:[<B>,<rank>=]scipy.linalg.pinvh(<a>[,cond=None,rcond=None,lower=True,return_rank=False,check_finite=True])
#通过特征值分解实现
#参数说明:check_finite同scipy.linalg.matmul_toeplitz()
a:指定原矩阵;为M×N array-like
cond,rcond:指定用于小奇异值的截断点;为float,默认为max(M,N)*eps,其中eps为<a>的数据类型的机器精度值
#用于确定<a>的有效秩;若均指定,则以rcond为准
#小于(r)cond*largest_singular_value的奇异值会被视为0
#eps is the corresponding machine precision value of the datatype of a
return_rank:指定是否返回<a>的有效秩;为bool
lower:若为False,则仅使用<a>的上三角中的元素
若为True,则仅使用<a>的下三角中的元素
B:返回<a>的伪逆;为N×M ndarray
rank:返回<a>的有效秩;为int
#仅当return_rank=True时返回该值
######################################################################################################################
scipy.linalg.subspace_angles(<A>,<B>)
######################################################################################################################
将矩阵指定对角线以上的元素替换为0:scipy.linalg.tril(<m>[,k=0])
将矩阵指定对角线以下的元素替换为0:scipy.linalg.triu(<m>[,k=0])
#参数说明:
m:指定矩阵;为array-like
#若维度超过2,会被分成多个矩阵(axis=n,n-1)并分别进行该操作
k:指定对角线;为int
#0表示主对角线,+i表示从下往上第i条上对角线,-i表示从上往下第i条下对角线
#实例:
>>> linalg.tril([[1,2,3,4,5],[6,7,8,9,10],[9,8,7,6,5],[4,3,2,1,0],[1,2,3,4,5]])
array([[1, 0, 0, 0, 0],
[6, 7, 0, 0, 0],
[9, 8, 7, 0, 0],
[4, 3, 2, 1, 0],
[1, 2, 3, 4, 5]])
>>> linalg.tril([[1,2,3,4,5],[6,7,8,9,10],[9,8,7,6,5],[4,3,2,1,0],[1,2,3,4,5]],2)
array([[1, 2, 3, 0, 0],
[6, 7, 8, 9, 0],
[9, 8, 7, 6, 5],
[4, 3, 2, 1, 0],
[1, 2, 3, 4, 5]])
>>> linalg.tril([[1,2,3,4,5],[6,7,8,9,10],[9,8,7,6,5],[4,3,2,1,0],[1,2,3,4,5]],-1)
array([[0, 0, 0, 0, 0],
[6, 0, 0, 0, 0],
[9, 8, 0, 0, 0],
[4, 3, 2, 0, 0],
[1, 2, 3, 4, 0]])
>>> linalg.tril([[[1,2],[3,4]],[[5,6],[7,8]]])
array([[[1, 0],
[3, 4]],
[[5, 0],
[7, 8]]])
>>> linalg.triu([[1,2,3,4,5],[6,7,8,9,10],[9,8,7,6,5],[4,3,2,1,0],[1,2,3,4,5]],-1)
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[ 0, 8, 7, 6, 5],
[ 0, 0, 2, 1, 0],
[ 0, 0, 0, 4, 5]])
(2)求解线性方程组:
求解线性方程组:scipy.linalg.solve(<a>,<b>[,sym_pos=False,lower=False,overwrite_a=False,overwrite_b=False,debug=None,check_finite=True,assume_a='gen',transposed=False])
#参数说明:check_finite参见scipy.linalg.matmul_toeplitz(),overwrite_a/overwrite_b同scipy.linalg.det()
a:指定系数矩阵;为N×N array-like
b:指定常数项;为N×M array-like
sym_pos:指定是否假设<a>为对称正定矩阵;为bool
#不推荐使用该参数,可使用assume_a="pos"来替代该参数;未来该参数会被移除
lower:若assume_a="gen",则忽略该参数,其他同scipy.linalg.pinvh()
assume_a:指定对<a>的假设;为"gen"(通用矩阵)/"sym"(对称矩阵)/"her"(埃尔米特矩阵)/"pos"(正定矩阵)
transposed:若为False,则求解<a>*x=<b>
若为True,则求解<a>^T*x=<b>(若<a>为复矩阵则raise NotImplementedError)
#实例:
>>> linalg.solve([[1,2],[3,4]],[1,1])
array([-1., 1.])
>>> linalg.solve([[1,2],[3,4]],[[1,1],[2,2]])
array([[0. , 0. ],
[0.5, 0.5]])
######################################################################################################################
求解带状系数矩阵的线性方程组:scipy.linalg.solve_banded(<l_and_u>,<ab>,<b>[,overwrite_ab=False,overwrite_b=False,debug=None,check_finite=True])
#要求系数矩阵为"带状矩阵"(Banded Matrix)
#参数说明:overwrite_ab/overwrite_b/check_finite/b参见scipy.linalg.solve()
l_and_u:指定<ab>中下/上对角线的数量;为(<l>,<u>),元素均为int
ab:指定系数矩阵;为(<l>+<u>+1)×N array-like
#若系数矩阵为[a11 a12 ... a1n
# a21 a22 ... a2n
# ... ... ... ...
# an1 an2 ... ann]
#则<ab>应写为[ 0 0 ... a1n #若某行已无非0元素,则不写
# ... ... ... ...
# 0 a12 ... a{n-1}n#上对角线
# a11 a12 ... ann #主对角线
# a21 a32 ... 0 #下对角线
# ... ... ... ...
# an1 0 ... 0 ]
#实例:
#原方程为:
# [5 2 -1 0 0] [0]
# [1 4 2 -1 0] [1]
#a=[0 1 3 2 -1] b=[2]
# [0 0 1 2 2] [2]
# [0 0 0 1 1] [3]
#有1条下对角线,2条上对角线
>>> ab=np.array([[0,0,-1,-1,-1],[0,2,2,2,2],[5,4,3,2,1],[1,1,1,1,0]])
>>> b=np.array([0,1,2,2,3])
>>> x=linalg.solve_banded((1,2),ab,b)
>>> x
array([-2.37288136, 3.93220339, -4. , 4.3559322 , -1.3559322 ])
######################################################################################################################
scipy.linalg.solveh_banded(<ab>,<b>[,overwrite_ab=False,overwrite_b=False,lower=False,check_finite=True])
######################################################################################################################
scipy.linalg.solve_circulant(<c>,<b>[,singular='raise',tol=None,caxis=-1,baxis=0,outaxis=0])
######################################################################################################################
求解三角系数矩阵的线性方程组:scipy.linalg.solve_triangular(<a>,<b>[,trans=0,lower=False,unit_diagonal=False,overwrite_b=False,debug=None,check_finite=True])
#要求系数矩阵为"三角矩阵"(Triangular Matrix)
#参数说明:其他参数同scipy.linalg.solve()
trans:若为0/"N",则求解<a>*x=<b>
若为1/"T",则求解<a>^T*x=<b>
若为2/"C",则求解<a>^H*x=<b>
unit_diagonal:是否假设对角线上的元素为1;为bool
#若为True,则直接将对角线上的元素当作1处理(即使实际上不是)
######################################################################################################################
scipy.linalg.solve_toeplitz(<c_or_cr>,<b>[,check_finite=True])
######################################################################################################################
求线性方程组的最小二乘解:[<x>,<residues>,<rank>,<s>=]scipy.linalg.lstsq(<a>,<b>[,cond=None,overwrite_a=False,overwrite_b=False,check_finite=True,lapack_driver="gelsd"])
#参数说明:overwrite_a/overwrite_b/check_finite同scipy.linalg.solve(),cond同scipy.linalg.pinv()
a:指定系数矩阵;为M×N array-like
b:指定常数项;为M×K array-like
lapack_drive:指定用于求解的LAPACK driver;为"gelsd"/"gelsy"/"gelss"
x:返回得到的解;为N×K ndarray
rank:返回<a>的有效秩;为int
s:返回<a>的奇异值;为1×min(<M>,<N>) ndarray
2.特征值与特征向量:
求解方阵的一般/广义特征值问题:[<w>,<vl>,<vr>=]scipy.linalg.eig(<a>[,b=None,left=False,right=True,overwrite_a=False,overwrite_b=False,check_finite=True,homogeneous_eigvals=False])
求解方阵的一般/广义特征值问题中的特征值:[<w>=]scipy.linalg.eigvals(<a>[,b=None,overwrite_a=False,check_finite=True,homogeneous_eigvals=False])
#"一般特征值问题"(Ordinary Eigenvalue Problem)是指Ax=λx,"广义特征值问题"(Generalized Eigenvalue Problem)则是指Ax=λBx
#参数说明:其他参数同同scipy.linalg.solve()
a:指定要求特征值的方阵(A);为N×N array-like
b:指定右侧矩阵(B);为N×N array-like,默认为单位矩阵
#用于广义特征值问题
left,right:分别指定是否返回左/右特征向量;均为bool
homogeneous_eigvals:指定是否以齐次坐标返回特征值;为bool
w:返回特征值;为1×N ndarray(homogeneous_eigvals=False时)/2×N ndarray(homogeneous_eigvals=True时)
vl,vr:分别返回经过归一化的左/右特征向量;均为N×N ndarray
#仅分别在left=True/right=True时返回
######################################################################################################################
求解埃尔米特矩阵的一般/广义特征值问题:[<w>,<v>=]scipy.linalg.eigh(<a>[,b=None,lower=True,eigvals_only=False,overwrite_a=False,overwrite_b=False,turbo=True,eigvals=None,type=1,check_finite=True,subset_by_index=None,subset_by_value=None,driver=None])
求解埃尔米特矩阵的一般/广义特征值问题中的特征值:[<w>=]scipy.linalg.eigvalsh(<a>[,b=None,lower=True,overwrite_a=False,overwrite_b=False,turbo=True,eigvals=None,type=1,check_finite=True,subset_by_index=None,subset_by_value=None,driver=None])
#参数说明:lower同scipy.linalg.pinvh(),其他参数同scipy.linalg.eig()
eigvals_only:指定是否只计算特征值;为bool
turbo,eigvals:已弃用
type:指定要求解的广义特征值问题的形式;为1/2/3
#1:<a>*<v>=<w>*<b>*<v>
#2:<a>*<b>*<v>=<w>*<v>
#3:<b>*<a>*<v>=<w>*<v>
subset_by_index:指定要返回的特征值的索引范围;为2-elements int iterable
#注意:索引从0开始;特征值按升序排列;定义的是闭区间[a,b];仅适用于"evr"/"evx"/"gvx"
subset_by_value:指定要返回的特征值的值范围;为2-elements int iterable
#注意:定义的是半开区间(a,b];使用np.inf表示无穷区间;仅适用于"evr"/"evx"/"gvx"
driver:指定用于求解的LAPACK driver;为"ev"/"evd"/"evr"/"evx"(一般特征值问题),"gv"/"gvd"/"gvx"(广义特征值问题)
w:返回选定的特征值;为1×M ndarray(1≤M≤N)
#特征值按升序排列
v:返回特征向量;为N×M ndarray
#仅当eigvals_only=False时返回该值
######################################################################################################################
scipy.linalg.eig_banded(<a_band>[,lower=False,eigvals_only=False,overwrite_a_band=False,select='a',select_range=None,max_ev=0,check_finite=True])
######################################################################################################################
scipy.linalg.eigh_tridiagonal(<d>,<e>[,eigvals_only=False,select='a',select_range=None,check_finite=True,tol=0.0,lapack_driver='auto'])
scipy.linalg.eigvalsh_tridiagonal(<d>,<e>[,select='a',select_range=None,check_finite=True,tol=0.0,lapack_driver='auto'])
3.分解
(1)LU分解:
对矩阵进行LU分解:[<p>,<l>,<u>=]scipy.linalg.lu(<a>[,permute_l=False,overwrite_a=False,check_finite=True])
#参数说明:其他参数同scipy.linalg.eig()
a:指定原矩阵;为M×N array-like
permute_l:为False表示分解为<a>=<p>*<l>*<u>
为True表示分解为<a>=<l>*<u>
p:返回置换矩阵;为M×M ndarray
#仅当permute_l=False时返回该值
l:返回下三角矩阵;为M×K ndarray(K=min(M,N))
u:返回上三角矩阵;为K×N ndarray
######################################################################################################################
[<lu>,<piv>=]scipy.linalg.lu_factor(<a>[,overwrite_a=False,check_finite=True])
######################################################################################################################
[<x>=]scipy.linalg.lu_solve(<lu_and_piv>,<b>[,trans=0,overwrite_b=False,check_finite=True])