精华内容
下载资源
问答
  • 采用雅克比矩阵进行对称矩阵特征值和特征向量计算
  • 对称矩阵特征值的图论意义 实对称矩阵特征值的图论意义
  • 2阶实对称矩阵特征值和特征向量的简单求解方法。因为2阶实对称矩阵的特殊性,可以直接使用初中的2阶方程 x = -b±sqrt(b*b -4*a*c) / 2*a进行求解。这方法在求解平面点的hessian矩阵很有用处。
  • 基于神经网络方法的对称矩阵特征值的求解.pdf
  • 使用Jacobi方法求取对称矩阵特征值和特征向量,vs2008下的
  • 本文用qr分解办法求对称矩阵特征值和特征向量,适合于大型矩阵求特征值,而且用的是迭代法,不同于matlab原有程序的qr分解
  • 经典Jacobi方法求解对称矩阵特征值(MATLAB描述),本函数使用经典Jacobi方法来计算一对称矩阵的特征值
  • 以下就从实对称矩阵的角度出发,利用特征值的极小极大原理,从普通特征值问题Ax=λxAx=\lambda xAx=λx衍生到广义特征值问题Ax=λBxAx=\lambda BxAx=λBx逐步讨论其特征值的性质。 【广义特征值问题】设A=(aij)∈Rn...

    前言

    在许多实际问题中,所产生的矩阵往往都是对称矩阵,比如我们耳熟能详的实对称矩阵也是重要的研究对象。以下就从实对称矩阵的角度出发,利用特征值的极小极大原理,从普通特征值问题 A x = λ x Ax=\lambda x Ax=λx衍生到广义特征值问题 A x = λ B x Ax=\lambda Bx Ax=λBx逐步讨论其特征值的性质。

    【广义特征值问题】设 A = ( a i j ) ∈ R n × n A=(a_{ij})\in \mathbb{R}^{n\times n} A=(aij)Rn×n n n n实对称矩阵, B = ( b i j ) ∈ R n × n B=(b_{ij})\in \mathbb{R}^{n\times n} B=(bij)Rn×n n n n实对称正定矩阵,使下式 A x = λ B x \mathbf{Ax=\lambda Bx} Ax=λBx 有非零解向量 x ∈ R n x\in \mathbb{R}^{n} xRn,则称 λ \lambda λ是矩阵 A A A相对于矩阵 B B B的特征值,且 x x x是属于 λ \lambda λ的特征向量。该问题常见于振动理论。

    我们可以发现

    • B ≠ I B\not=I B=I时,该问题是广义特征值问题
    • B = I B=I B=I时,该问题是普通特征值问题

    思路:如何利用极小极大原理求第 k k k个特征值及奇异值?

    利用极大极小原理,我们先确定 n n n阶实对称阵的最大最小特征值,然后逐步求第2大和第2小特征值进而归纳到求第 k k k大和第 k k k小特征值。

    本文就对称矩阵特征值的极性与直积做以梳理,完整定理证明请参考西工大的《矩阵论》[1]。

    一、实对称矩阵的瑞利商与广义瑞利商性质

    我们在讨论实对称矩阵的特征值时,往往会通过实对称阵的瑞利商来研究,因为瑞利商是由如下特征值问题推导出来的,它可以直接求出矩阵的特征值。
    A x = λ x ⇒ x T A x = λ x T x ⇒ λ = x T A x x T x = R ( x ) Ax=\lambda x \Rightarrow x^TAx=\lambda x^Tx \Rightarrow \lambda=\frac{x^TAx}{x^Tx}=R(x) Ax=λxxTAx=λxTxλ=xTxxTAx=R(x)

    【瑞利商定义】设 A = ( a i j ) ∈ R n × n A=(a_{ij})\in \mathbb{R}^{n\times n} A=(aij)Rn×n n n n实对称矩阵, x ∈ R n x\in \mathbb{R}^{n} xRn,则称下式为矩阵 A A A的瑞利商( Rayleigh \text{Rayleigh} Rayleigh商) R ( x ) = x T A x x T x ( x ≠ 0 ) \mathbf{R(x) = \frac{x^TAx}{x^Tx}} \quad (x\not=\mathbf{0}) R(x)=xTxxTAx(x=0)

    【广义瑞利商定义】设 A = ( a i j ) ∈ R n × n , B = ( b i j ) ∈ R n × n A=(a_{ij})\in \mathbb{R}^{n\times n},B=(b_{ij})\in \mathbb{R}^{n\times n} A=(aij)Rn×n,B=(bij)Rn×n均是 n n n实对称矩阵,且 B B B正定 x ∈ R n x\in \mathbb{R}^{n} xRn,则称下式为矩阵 A A A相对于矩阵 B B B广义瑞利商 R ( x ) = x T A x x T B x ( x ≠ 0 ) \mathbf{R(x) = \frac{x^TAx}{x^TBx}} \quad (x\not=\mathbf{0}) R(x)=xTBxxTAx(x=0)

    • 【性质1】: R ( x ) R(x) R(x) x x x连续函数
    • 【性质2】: R ( x ) R(x) R(x) x x x的零次齐次函数(齐次性 R ( k x ) = R ( x ) R(kx)=R(x) R(kx)=R(x)
      事实上,对于任意实数 λ ≠ 0 \lambda \not=0 λ=0有下式分别满足齐次性和零次
      R ( λ x ) = R ( x ) = λ 0 R ( x ) R(\lambda x)=R(x)=\lambda^0 R(x) R(λx)=R(x)=λ0R(x)
    • 【性质3】:当 x x x是由 x 0 ≠ 0 x_0\not=0 x0=0张成的空间时, R ( x ) R(x) R(x)是一常数
    • 【性质4】: R ( x ) R(x) R(x)最大最小值存在,且能够在单位球面 S = { x ∣ x ∈ R n , ∥ x ∥ 2 = 1 } S=\{x|x\in \mathbb{R}^n,\|x\|_2=1\} S={xxRn,x2=1}上达到
    • 【性质5】:非零向量 x 0 x_0 x0 R ( x ) R(x) R(x)驻点 ⇔ x 0 \Leftrightarrow x_0 x0 A x = λ B x Ax=\lambda Bx Ax=λBx特征向量,当 B = I B=I B=I时对应于瑞利商问题同理,通过矩阵求导可得

    一般情况下,我们令实对称矩阵 A A A的特征值按从小到大顺序排列如下
    λ 1 ≤ λ 2 ≤ . . . ≤ λ n \lambda_1 \le \lambda_2 \le... \le \lambda_n λ1λ2...λn
    对应标准正交特征向量系为 p 1 , p 2 , . . . , p n p_1,p_2,...,p_n p1,p2,...,pn

    【定理】设 A = ( a i j ) ∈ R n × n A=(a_{ij})\in \mathbb{R}^{n\times n} A=(aij)Rn×n n n n实对称矩阵,则有 min ⁡ x ≠ 0 R ( x ) = λ 1 , max ⁡ x ≠ 0 R ( x ) = λ n , λ 1 ≤ R ( x ) ≤ λ n \mathbf{\min_{x\not=\mathbf{0}} R(x) = \lambda_1,\quad \max_{x\not=\mathbf{0}} R(x) = \lambda_n ,\quad \lambda_1 \le R(x) \le \lambda_n} x=0minR(x)=λ1,x=0maxR(x)=λn,λ1R(x)λn

    【证明】任取 0 ≠ x ∈ R n \mathbf{0}\not=x \in \mathbb{R}^n 0=xRn,则有
    x = c 1 p 1 + c 2 p 2 + . . . + c n p n ( c 1 2 + c 2 2 + . . . + c n 2 ≠ 0 ) x=c_1p_1+c_2p_2+...+c_np_n \quad (c_1^2+c_2^2+...+c_n^2\not=0) x=c1p1+c2p2+...+cnpn(c12+c22+...+cn2=0)
    由于 p 1 , p 2 , . . . , p n p_1,p_2,...,p_n p1,p2,...,pn是正交特征向量系,所以有 x i = c i p i x_i=c_ip_i xi=cipi
    于是有
    A x = λ x = λ 1 c 1 p 1 + λ 2 c 2 p 2 + . . . + λ n c n p n x T A x = c 1 2 λ 1 + c 2 2 λ 2 + . . . + c n 2 λ n x T x = c 1 2 + c 2 2 + . . . + c n 2 \begin{aligned} Ax&=\lambda x=\lambda_1c_1p_1+\lambda_2c_2p_2+...+\lambda_nc_np_n\\ x^TAx & =c_1^2\lambda_1+c_2^2\lambda_2+...+c_n^2\lambda_n \\ x^Tx & =c_1^2+c_2^2+...+c_n^2 \\ \end{aligned} AxxTAxxTx=λx=λ1c1p1+λ2c2p2+...+λncnpn=c12λ1+c22λ2+...+cn2λn=c12+c22+...+cn2
    k i = c i 2 c 1 2 + c 2 2 + . . . + c n 2 k_i=\frac{c_i^2}{c_1^2+c_2^2+...+c_n^2} ki=c12+c22+...+cn2ci2,其中 k 1 + k 2 + . . . + k n = 1 k_1+k_2+...+k_n=1 k1+k2+...+kn=1,则有
    R ( x ) = x T A x x T x = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n R(x) =\frac{x^TAx}{x^Tx}=k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n R(x)=xTxxTAx=k1λ1+k2λ2+...+knλn
    简单起见,假设 A A A 2 2 2阶实对称阵,即仅有两个特征值 λ 1 , λ 2 \lambda_1,\lambda_2 λ1,λ2满足 R ( x ) = k 1 λ 1 + k 2 λ 2    ( k 1 + k 2 = 1 ) R(x)=k_1\lambda_1+k_2 \lambda_2\;(k_1+k_2=1) R(x)=k1λ1+k2λ2(k1+k2=1),则如下图所示

    从上图,我们可以清晰的看出 R ( x ) R(x) R(x) x x x连续函数,该集合也被称为凸包,由此可得
    λ 1 ≤ R ( x ) ≤ λ n \lambda_1 \le R(x) \le \lambda_n λ1R(x)λn
    可以通过如下式子验证 R ( p 1 ) = λ 1 R(p_1)=\lambda_1 R(p1)=λ1
    R ( p i ) = p i T A p i p i T p i = λ i R(p_i) =\frac{p_i^TAp_i}{p_i^Tp_i}=\lambda_i R(pi)=piTpipiTApi=λi
    有了 p k p_k pk x k x_k xk,我们可以直接求得第 k k k小特征值 λ k \lambda_k λk。但问题来了,如果我们不知道 p k p_k pk或者不想依赖于 x k x_k xk,我们如何求得第 k k k小特征值 λ k \lambda_k λk呢?这就需要下面一章的极小极大原理了。

    【重要推论】若 λ 1 = . . . = λ k ( 1 ≤ k ≤ n ) \lambda_1=...=\lambda_k(1\le k \le n) λ1=...=λk(1kn),则在 ∥ x ∥ 2 = 1 \|x\|_2=1 x2=1上, R ( x ) R(x) R(x)的所有极小点为 l 1 p 1 + l 2 p 2 + . . . + l k p k \mathbf{l_1p_1+l_2p_2+...+l_kp_k} l1p1+l2p2+...+lkpk 其中, l i ∈ R ( i = 1 , . . . , k ) l_i\in R(i=1,...,k) liR(i=1,...,k),且满足 l 1 2 + l 1 2 + . . + l k 2 = 1 l_1^2+l_1^2+..+l_k^2=1 l12+l12+..+lk2=1.

    二、普通与广义特征值的极小极大原理

    由上章,我们得到几个工具,令 V n = span { x 1 , x 2 , . . . , x n }    ( λ 1 ≤ λ 2 ≤ . . . ≤ λ n ) V_n=\text{span}\{x_1,x_2,...,x_n\}\;(\lambda_1 \le \lambda_2 \le... \le \lambda_n ) Vn=span{x1,x2,...,xn}(λ1λ2...λn)则有
    R ( x ) = x T A x x T x = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n R(x) =\frac{x^TAx}{x^Tx}=k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n R(x)=xTxxTAx=k1λ1+k2λ2+...+knλn
    λ 1 ≤ R ( x ) ≤ λ n ⇒ { min ⁡ x ≠ 0 , x ∈ V n R ( x ) = λ 1 max ⁡ x ≠ 0 , x ∈ V n R ( x ) = λ n \lambda_1 \le R(x) \le \lambda_n \Rightarrow \begin{cases} \min_{x\not=\mathbf{0},x\in V_n} R(x) = \lambda_1 \\ \max_{x\not=\mathbf{0},x\in V_n} R(x) = \lambda_n \\ \end{cases} λ1R(x)λn{minx=0,xVnR(x)=λ1maxx=0,xVnR(x)=λn
    当我们想求 λ 2 , λ n − 1 \lambda_2,\lambda_{n-1} λ2,λn1时,可以通过缩小张成的子空间得到
    λ 2 = min ⁡ x ≠ 0    R ( x ) = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n s . t .      k 1 = 0 ⋮ λ i = min ⁡ x ≠ 0    R ( x ) = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n s . t .      k 1 = k 2 = . . . = k i − 1 = 0 \begin{aligned} \lambda_{2}= \min_{x\not=0} & \; R(x) =k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n\\ s.t. & \;\; k_{1}=0 \\ \end{aligned} \\ \vdots \\ \begin{aligned} \lambda_{i}= \min_{x\not=0} & \; R(x) =k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n\\ s.t. & \;\; k_1=k_2=...=k_{i-1}=0 \\ \end{aligned} \\ λ2=x=0mins.t.R(x)=k1λ1+k2λ2+...+knλnk1=0λi=x=0mins.t.R(x)=k1λ1+k2λ2+...+knλnk1=k2=...=ki1=0
    同理得
    λ n − 1 = max ⁡ x ≠ 0    R ( x ) = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n s . t .      k n = 0 ⋮ λ n − i − 1 = min ⁡ x ≠ 0    R ( x ) = k 1 λ 1 + k 2 λ 2 + . . . + k n λ n s . t .      k n = k n − 1 = . . . = k n − i = 0 \begin{aligned} \lambda_{n-1}= \max_{x\not=0} & \; R(x) =k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n\\ s.t. & \;\; k_{n}=0 \\ \end{aligned} \\ \vdots \\ \begin{aligned} \lambda_{n-i-1}= \min_{x\not=0} & \; R(x) =k_1\lambda_1+k_2\lambda_2+...+k_n\lambda_n\\ s.t. & \;\; k_n=k_{n-1}=...=k_{n-i}=0 \\ \end{aligned} \\ λn1=x=0maxs.t.R(x)=k1λ1+k2λ2+...+knλnkn=0λni1=x=0mins.t.R(x)=k1λ1+k2λ2+...+knλnkn=kn1=...=kni=0
    因此,我们可以归纳出如下定理

    【定理】设 x ∈ L ( p r , p r + 1 , . . . , p s ) , 1 ≤ r ≤ s ≤ n x\in L(p_r,p_{r+1},...,p_s),1 \le r \le s \le n xL(pr,pr+1,...,ps),1rsn,则有 min ⁡ x ≠ 0    R ( x ) = λ r max ⁡ x ≠ 0    R ( x ) = λ s \mathbf{\min_{x\not=0} \; R(x) =\lambda_r \quad \max_{x\not=0} \; R(x) =\lambda_s} x=0minR(x)=λrx=0maxR(x)=λs

    2.1 引出问题:由于 V k V_k Vk不唯一导致得到多个特征值

    但以上定理在 p r , p s p_r,p_{s} pr,ps未知下无法使用,因此我们不再指定让某个系数 k i = 0 k_i=0 ki=0,而是选取 k k k维子空间 V k V_k Vk来求,由于 V k V_k Vk是不唯一的,因此可能会得到多个特征值,例如我们想要得到 λ 2 \lambda_2 λ2,则选取 V n − 1 V_{n-1} Vn1,有如下两种情况

    min ⁡ x ≠ 0    R ( x ) = { λ 1        if      x 1 ∈ V n − 1 λ 2        if      x 1 ∉ V n − 1 \min_{x\not=0}\; R(x)= \begin{cases} \lambda_{1} \quad \;\;\; \text{if} \;\; x_1 \in V_{n-1} \\ \lambda_{2} \quad \;\;\; \text{if} \;\; x_1 \notin V_{n-1} \\ \end{cases} x=0minR(x)={λ1ifx1Vn1λ2ifx1/Vn1
    max ⁡ x ≠ 0    R ( x ) = { λ n        if      x n ∈ V n − 1 λ n − 1 if      x n ∉ V n − 1 \max_{x\not=0}\; R(x)= \begin{cases} \lambda_{n} \quad \;\;\; \text{if} \;\; x_n \in V_{n-1} \\ \lambda_{n-1} \quad \text{if} \;\; x_n \notin V_{n-1} \\ \end{cases} x=0maxR(x)={λnifxnVn1λn1ifxn/Vn1

    2.2 解决问题:使用极大极小原理固定特征向量

    对于上述子空间 V k V_k Vk不唯一情况,得到
    min ⁡ 0 ≠ x ∈ V n − 1 R ( x ) ≤ λ 2 max ⁡ 0 ≠ x ∈ V n − 1   R ( x ) ≥ λ n − 1 \min_{0\not =x\in V_{n-1}} R(x)\le \lambda_{2} \quad \max_{0\not =x\in V_{n-1}}\ R(x)\ge \lambda_{n-1} 0=xVn1minR(x)λ20=xVn1max R(x)λn1
    为解决此问题,我们使用极小极大原理得到
    λ 2 = max ⁡ V n − 1 [ min ⁡ 0 ≠ x ∈ V n − 1 R ( x ) ] ,      λ n − 1 = min ⁡ V n − 1 [ max ⁡ 0 ≠ x ∈ V n − 1 R ( x ) ] \lambda_{2} = \max_{V_{n-1}} \left[ \min_{0\not =x\in V_{n-1}} R(x) \right] ,\; \; \lambda_{n-1} = \min_{V_{n-1}} \left[ \max_{0\not =x\in V_{n-1}} R(x) \right] λ2=Vn1max[0=xVn1minR(x)],λn1=Vn1min[0=xVn1maxR(x)]
    为此,我们归纳出一般的式子,我们

    【定理】设 V k V_k Vk R n \mathbb{R}^n Rn中的任意一个 k k k维子空间,则普通特征值问题与广义特征值问题从小到大的第 k k k个特征值和 n − ( k − 1 ) n-(k-1) n(k1)个特征值具有如下极小极大性质
    λ n − ( k − 1 ) = max ⁡ V k [ min ⁡ 0 ≠ x ∈ V k R ( x ) ] ,      λ k = min ⁡ V k [ max ⁡ 0 ≠ x ∈ V k R ( x ) ] \mathbf{\lambda_{n-(k-1)} = \max_{V_{k}} \left[ \min_{0\not =x\in V_{k}} R(x) \right] ,\; \; \lambda_{k} = \min_{V_{k}} \left[ \max_{0\not =x\in V_{k}} R(x) \right] } λn(k1)=Vkmax[0=xVkminR(x)],λk=Vkmin[0=xVkmaxR(x)]

    • 左式被称为特征值的极大极小原理
    • 右式被称为特征值的极小极大原理

    三、矩阵奇异值的极小极大性质

    我们通过矩阵瑞利商的极小极大原理,可以衍生到解决奇异值问题,我们将矩阵 A ∈ R r m × n A\in \mathbb{R}_r^{m\times n} ARrm×n的奇异值排列如下 [其中, σ i = λ i ( A T A ) \sigma _i = \sqrt{\lambda_i (A^TA)} σi=λi(ATA) ]
    0 = σ 1 = σ 2 = . . . = σ n − r ≤ σ n − r + 1 ≤ . . . ≤ σ n 0=\sigma _1 =\sigma _2 =... =\sigma _{n-r} \le \sigma _{n-r+1} \le ... \le \sigma _{n} 0=σ1=σ2=...=σnrσnr+1...σn

    我们令 B = A T A B=A^TA B=ATA,则实对称矩阵 B B B的瑞利商如下
    R ( x ) = x T B x x T x = x T ( A T A ) x x T x = ( A x ) T A x x T x = ∥ A x ∥ 2 2 ∥ x ∥ 2 2 = λ = σ R(x) =\frac{x^TBx}{x^Tx} =\frac{x^T(A^TA)x}{x^Tx}=\frac{(Ax)^TAx}{x^Tx}=\frac{\|Ax\|_2^2}{\|x\|_2^2}=\lambda=\sqrt{\sigma} R(x)=xTxxTBx=xTxxT(ATA)x=xTx(Ax)TAx=x22Ax22=λ=σ
    则矩阵 A A A的第 k k k个奇异值和第 n − k + 1 n-k+1 nk+1个奇异值具有如下极小极大性质
    σ n − ( k − 1 ) = max ⁡ V k [ min ⁡ 0 ≠ x ∈ V k ∥ A x ∥ 2 ∥ x ∥ 2 ] ,      σ k = min ⁡ V k [ max ⁡ 0 ≠ x ∈ V k ∥ A x ∥ 2 ∥ x ∥ 2 ] \sigma _{n-(k-1)} = \max_{V_{k}} \left[ \min_{0\not =x\in V_{k}}\frac{\|Ax\|_2}{\|x\|_2} \right] ,\; \; \sigma _{k} = \min_{V_{k}} \left[ \max_{0\not =x\in V_{k}}\frac{\|Ax\|_2}{\|x\|_2} \right] σn(k1)=Vkmax[0=xVkminx2Ax2],σk=Vkmin[0=xVkmaxx2Ax2]
    其中, V k V_k Vk R n \mathbb{R}^n Rn中的任意一个 k k k维子空间。

    附录:矩阵直积( Kronecker \text{Kronecker} Kronecker积)的概念

    运用矩阵的直积运算,能够将线性矩阵方程转换为线性代数方程组进行求解

    【定义】设 A = ( a i j ) ∈ C m × n , B = ( b i j ) ∈ C p × q A=(a_{ij})\in \mathbb{C}^{m\times n},B=(b_{ij})\in \mathbb{C}^{p\times q} A=(aij)Cm×n,B=(bij)Cp×q,则称如下分块矩阵为 A A A B B B的直积( Kronecker \text{Kronecker} Kronecker积)

    参考文献

    程云鹏, 凯院, 仲. 矩阵论[M]. 西北工业大学出版社, 2006.

    展开全文
  • 基于CORDIC算法的高精度浮点对称矩阵特征值分解的FPGA实现.pdf
  • Lanczos法的目的:将实对称矩阵转换成为三对角矩阵(稀疏矩阵),从而便于计算机储存和后续的计算。 在三对角矩阵矩阵上,采用QR分解,得到矩阵的特征值。 # -*- coding: utf-8 -*- """ Created ...

     Lanczos法的目的:将实对称矩阵转换成为三对角矩阵(稀疏矩阵),从而便于计算机储存和后续的计算。

    在三对角矩阵矩阵上,采用QR分解,得到矩阵的特征值。

    # -*- coding: utf-8 -*-
    """
    Created on Tue Nov 20 12:41:40 2018
    
    @author: yujin.wang
    """
    import numpy as np
    import scipy as sci
    import matplotlib.pyplot as plt
    import time
    import sys
    
    def lanczos(A,b,nmax):
    	m = np.size(A,1)
    	alpha = []
    	beta = [0]
    	qprev = np.zeros(m)
    	q = b / np.linalg.norm(b)
    	for n in range(nmax):
    		v = np.dot(q,A) #*sci.linalg.inv(q)
    		temp = np.dot(v,q.T)
    		alpha.append(temp[0][0,0])
    		v = v - np.dot(beta[-1],qprev)-np.dot(alpha[-1],q)
    		beta.append(sci.linalg.norm(v))
    		qprev = q
    		q = v/beta[-1]
    	beta = beta[1:-1]
    	T = np.diag(alpha) + np.diag(beta,1) +np.diag(beta,-1)
    	return T
    
    
    def qreigen(A,num=100):
    	m = np.size(A,1)
    	p = np.eye(m)
    	for i in range(num):
    		v = np.diag(A)
    		q,r = sci.linalg.qr(A)
    		A = np.dot(r,q)
    		p = np.dot(p,q)
    		tol = max(np.diag(A))-max(v)
    		print 'TOL:',tol,'Max. Eig:',max(v)
    		if np.abs(tol) <1e-6:
    			break
    #	s = np.diag(np.diag(r))
    	return p,np.diag(A)
    
    if __name__ == '__main__':
    	A = np.matrix([[5,1,3],[1,2,0],[3,0,11]])
    	print np.linalg.eig(A)[0]
    	print '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$'
    	p,s = qreigen(A)
    	print s
    	print '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$'
    	b = np.matrix([1,1,1])
    	tridiag = lanczos(A,b,23)
    	p,s = qreigen(tridiag,num=200)
    	print max(s),min(s)

    参考:https://baike.baidu.com/item/Lanczos%E7%AE%97%E6%B3%95/9849921?fr=aladdin 

               http://www.cnblogs.com/qxred/p/dcalgorithm.html

               http://www.doc88.com/p-1446190703774.html

     

    展开全文
  • 基于MPI的估计对称矩阵特征值的串行和并行程序优化。用于课程报告参考和期末复习以及对MPI并行程序优化进行进一步学习。
  • 对 intel Math Kernel Library 中的实对称矩阵特征值求解器(使用 Divide and Conquer 方式)的 C++ 封装,可以轻松愉快高效地求解实对称矩阵的特征值与特征矢量。

            直接调用 intel Math Kernel Library 是比较麻烦的,而第三方的线性代数计算库往往效率不佳。于是我模仿 Eigen 的风格对 intel MKL 函数做了简单的封装。以下代码中的 EigenSolver 类能够轻松愉快高效地求解实对称矩阵的特征值和特征向量,也可以高效地求解逆矩阵。为了效率优先,特征值求解与逆矩阵求解都是直接在原矩阵上进行,不保存原来的矩阵。

    /*
    * Symmetric Dense Matrix Class
    */
    
    #ifndef MATRIX_CLASS_H
    #define MATRIX_CLASS_H
    
    #include <iostream>
    #include <iomanip>
    #include "mkl_lapacke.h"
    
    class EigenSolver;
    class Matrix;
    
    class Matrix
    {
    public:
    	Matrix(std::size_t rVal = 0)
    	{
    		_Rows = rVal;
    		_Cols = _Rows;
    		_Data = new double[_Rows * _Cols];
    	}
    	Matrix(std::size_t rVal, std::size_t cVal)
    	{
    		_Rows = rVal;
    		_Cols = cVal;
    		_Data = new double[_Rows * _Cols];
    	}
    	Matrix(const Matrix& rhs)
    	{
    		_Rows = rhs._Rows;
    		_Cols = rhs._Cols;
    		_Data = new double[_Rows * _Cols];
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(_Data + ix) = *(rhs._Data + ix);
    		}
    	}
    	// the deconstructor function
    	~Matrix()
    	{
    		delete[] _Data;
    	}
    	void resize(std::size_t rVal, std::size_t cVal)
    	{
    		delete[] _Data;
    		_Rows = rVal;
    		_Cols = cVal;
    		_Data = new double[_Rows * _Cols];
    	}
    	// member functions
    	std::size_t rows() const
    	{
    		return _Rows;
    	}
    	std::size_t cols() const
    	{
    		return _Cols;
    	}
    	// inverse matrix
    	void inverse()
    	{
    		int *ipiv = new int[_Rows * _Cols];
    		LAPACKE_dsytrf(LAPACK_ROW_MAJOR, 'U', _Rows, _Data, _Rows, ipiv);
    		LAPACKE_dsytri(LAPACK_ROW_MAJOR, 'U', _Rows, _Data, _Rows, ipiv);
    		delete[] ipiv;
    		for(std::size_t j = 0; j < _Cols; ++j)
    		{
    			for(std::size_t i = j + 1; i < _Rows; ++i)
    				_Data[i * _Cols + j] = _Data[j * _Cols + i];
    		}
    	}
    	// overloaded operations
    	Matrix& operator=(const Matrix& rhs)
    	{
    		resize(rhs._Rows, rhs._Cols);
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(_Data + ix) = *(rhs._Data + ix);
    		}
    		return *this;
    	}
    	Matrix& operator*=(double scala)
    	{
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(_Data + ix) *= scala;
    		}
    		return *this;
    	}
    	Matrix& operator+=(const Matrix& mat)
    	{
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(_Data + ix) += *(mat._Data + ix);
    		}
    		return *this;
    	}
    	Matrix& operator-=(const Matrix& mat)
    	{
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(_Data + ix) -= *(mat._Data + ix);
    		}
    		return *this;
    	}
    	Matrix operator-() const
    	{
    		Matrix mat(_Rows, _Cols);
    		for(std::size_t ix = 0; ix != _Rows * _Cols; ++ix)
    		{
    			*(mat._Data + ix) = 0 - *(_Data + ix);
    		}
    		return mat;
    	}
    	double& operator()(std::size_t rVal, std::size_t cVal)
    	{
    		return _Data[rVal*_Cols + cVal];
    	}
    	const double& operator()(std::size_t rVal, std::size_t cVal) const
    	{
    		return _Data[rVal*_Cols + cVal];
    	}
    	// friend classes and functions
    	friend class EigenSolver;
    	friend Matrix operator+(const Matrix&, const Matrix&);
    	friend Matrix operator-(const Matrix&, const Matrix&);
    	friend Matrix operator*(const Matrix&, double);
    	friend Matrix operator*(double, const Matrix&);	
    	// for test
    	friend std::ostream& operator<<(std::ostream&, const Matrix&);
    protected:
    	std::size_t _Rows;
    	std::size_t _Cols;
    	double* _Data; // row major array
    };
    
    Matrix operator+(const Matrix& lhs, const Matrix& rhs)
    {
    	Matrix sum(lhs._Rows, lhs._Cols);
    	for(std::size_t ix = 0; ix != lhs._Rows * lhs._Cols; ++ix)
    	{
    		*(sum._Data + ix) = *(lhs._Data + ix) + *(rhs._Data + ix);
    	}
    	return sum;
    }
    
    Matrix operator-(const Matrix& lhs, const Matrix& rhs)
    {
    	Matrix diff(lhs._Rows, lhs._Cols);
    	for(std::size_t ix = 0; ix != lhs._Rows * lhs._Cols; ++ix)
    	{
    		*(diff._Data + ix) = *(lhs._Data + ix) - *(rhs._Data + ix);
    	}
    	return diff;
    }
    
    Matrix operator*(const Matrix& mat, double scala)
    {
    	Matrix prod(mat._Rows, mat._Cols);
    	for(std::size_t ix = 0; ix != mat._Rows * mat._Cols; ++ix)
    	{
    		*(prod._Data + ix) = *(mat._Data + ix) * scala;
    	}
    	return prod;
    }
    
    Matrix operator*(double scala, const Matrix& mat)
    {
    	return mat * scala;
    }
    
    std::ostream& operator<<(std::ostream& os, const Matrix& mat)
    {
    	for(std::size_t i = 0; i != mat.rows(); ++i)
    	{
    		for(std::size_t j = 0; j != mat.cols(); ++j)
    		{
    			os << mat(i, j) << "\t";
    		}
    		os << std::endl;
    	}
    	return os;
    }
    
    class EigenSolver
    {
    public:
    	EigenSolver(Matrix& mat) : _EigenVecs(mat)
    	{
    		_Size = mat.rows();
    		_EigenVals.resize(_Size, 1);
    		LAPACKE_dsyevd(LAPACK_ROW_MAJOR, 'V', 'U', _Size, _EigenVecs._Data, _Size, _EigenVals._Data);
    	}
    	const Matrix& eigenvalues() const
    	{
    		return _EigenVals;
    	}
    	const Matrix& eigenvectors() const
    	{
    		return _EigenVecs;
    	}
    	friend std::ostream& operator<<(std::ostream&, const EigenSolver&);
    private:
    	std::size_t _Size;
    	Matrix _EigenVals;
    	Matrix& _EigenVecs;
    };
    
    std::ostream& operator<<(std::ostream& os, const EigenSolver& eigen)
    {
    	for(std::size_t ix = 0; ix != eigen._Size; ++ix)
    	{
    		os << "eigen value: " << eigen._EigenVals(ix, 0) << std::endl;
    		os << "corresponding eigen vector:" << std::endl;
    		for(std::size_t j = 0; j != eigen._Size; ++j)
    		{
    			os << eigen._EigenVecs(j, ix) << std::endl;
    		}
    	}
    	return os;
    }
    
    #endif

            输出结果为

    ------------------------------------
    --> mat:
    1	3	6	7	
    3	2	5	2	
    6	5	1	0	
    7	2	0	4	
    ------------------------------------
    eigen value: -7.71991
    corresponding eigen vector:
    -0.679611
    -0.170638
    0.565471
    0.435033
    eigen value: -1.9569
    corresponding eigen vector:
    -0.41358
    0.759732
    -0.445459
    0.230925
    eigen value: 3.92217
    corresponding eigen vector:
    -0.122992
    0.457809
    0.530801
    -0.70252
    eigen value: 13.7546
    corresponding eigen vector:
    0.593257
    0.42907
    0.44728
    0.513698

    展开全文
  • 对称矩阵特征值与特征向量

    万次阅读 2018-08-20 21:23:15
    对称矩阵: A = A的转置 这里讨论的是实对称矩阵好的性质: 1, 特征值是实数 ...正定矩阵:首先是一个对称矩阵,是对称矩阵很好的子类。正定矩阵的所有特征值都是正数。所有的主元都...

    对称矩阵: A = A的转置

    这里讨论的是实对称矩阵

    两个好的性质:

    1, 特征值是实数

    2,特征向量是两两正交的

     

    一个对称矩阵A可以进行如下分解:

    A=Q\LambdaQ的转置

     

    对于对称矩阵来说,有一个性质:主元的符号与特征值得符号是相同的。即正主元的个数等于正的特征值的个数。

     

    正定矩阵:首先是一个对称矩阵,是对称矩阵一个很好的子类。正定矩阵的所有特征值都是正数。所有的主元都是正数。

    所有的子行列式都是正的。

    展开全文
  • A所有的特征值按大小排序如下:λ1≥...≥λn\lambda_1\ge...\ge\lambda_nλ1​≥...≥λn​ 证明:对∀α∈Rn,且α≠0,都满足\forall\alpha\in R^n,且\alpha\ne0,都满足∀α∈Rn,且α​=0,都满足 λn≤α′Aα...
  • 本文研究实对称矩阵特征值的最大值与最小值。定理设 是 阶实对称矩阵,记 分别是 中所有特征值中的最大值与最小值,则 证明:这里只证关于最大值的那部分。最小值的证明是完全类似的。因为 是实对称矩阵,所以 有由 ...
  • 定理:2阶实对称矩阵H的特征值是实数 H=[a,b;b,c] a,b,c是实数,λ 是特征值 A=[a-λ,b;b,c-λ] 特征值求解方法为:(a- λ )(c- λ) - b2 = 0 求解方程得到两根为:λ=(a+c)±(a+c)2-4(ac-b2)2 ...
  • 特征值篇1——特征值和特征向量特征值篇1--特征值和特征向量_thompson的博客-CSDN博客​blog.csdn.net特征值篇2——特征子空间特征值篇2--特征子空间_thompson的博客-CSDN博客​blog.csdn.net特征值篇3——矩阵可...
  • 对称矩阵 所有特征值 任意阶数矩阵
  • [ evals ] = eig_LDLT( A,range,epsilon ) Compute the eigenvalue of symmetric real matrix A in RANGE.
  • 根据网上资源(C++)改编的 c#版本;测试成功;
  • 基于java语言的对称矩阵特征值求解方法,附带讲解PPT和源代码。
  • 我通过外部文件导入建立了一无向图的邻接矩阵,是一对称矩阵,矩阵规模较大,然后计算特征值和特征向量的时候,为什么特征值和特征向量里面会出现复数?该怎样处理?谢谢了!
  • 针对较高维矩阵的特征值求解问题,定义实对称矩阵的两个特征值函数,分别用来求解实对称矩阵的前p 最大特征值和最小特征值的和;讨论了这两个特征值函数的性质,列举这两函数在现代控制理论等领域中的应用;最后给...
  • 该程序用C++实现对任意阶的是对称矩阵特征值和特征向量,本程序给的例子是读取matrix.txt这120阶矩阵。
  • Householder+QR法求解实对称矩阵全部特征值和特征向量的类,经过一些优化,速度比一般的版本要快一些。
  • 本文主要针对线性代数中的正定矩阵、实对称矩阵矩阵特征值分解以及矩阵 SVD 分解进行总结。 如果你对这篇文章可感兴趣,可以点击「【访客必读 - 指引页】一文囊括主页内所有高质量博客」,查看完整博客分类与对应...
  • 矩阵的特征值与特征向量的计算的matlab实现,幂法、反幂法和位移反幂法、雅可比(Jacobi)方法、豪斯霍尔德(Householder)方法、实对称矩阵的三对角化、QR方法、求根位移QR方法计算实对称矩阵特征值、广义特征值问题...
  • 从机器学习、量子计算、物理到许多数学和工程的问题,都可以通过找到一个矩阵特征值和特征向量来解决。根据定义(标量λ、向量v是特征值、特征向量A):视觉上,Av与特征向量v位于同一直线上。这里有些例子。然而,Ax...
  • 利用矩阵的分解及矩阵的计算技巧,得到了奇异可对称矩阵特征值新的相对扰动上界,改进了以往的结果,得到3全新的上界定理。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,000
精华内容 10,800
关键字:

对称矩阵的特征值个数