Syslab使用手册
⋮
2026a

# eigen

计算 A 的特征值分解，返回一个特征分解对象 F，其中包含 F.values 中的特征值和矩阵 F.vectors 列中的特征向量。 （第 k 个特征向量可以从 F.vectors[:, k] 中获得）

函数库: TyMath

对于一般的非对称矩阵，可以在特征向量计算之前指定矩阵的平衡方式。选项 permute=true 使矩阵更接近于上三角矩阵，并且 scale=true 按其对角线元素缩放矩阵，使行和列的范数更相等。这两个选项的默认值都是 true。

默认情况下，特征值和向量按字典顺序按 (real(λ),imag(λ)) 排序。可以将不同的比较函数 by(λ) 传递给 sortby，或者您可以传递 sortby=nothing 以离开任意顺序的特征值。一些特殊的矩阵类型（例如 Diagonal 或 SymTridiagonal）可能会实现自己的排序约定并且不接受 sortby 关键字。

# 语法

e,W = eigen(A)
e,W = eigen(A,B)

# 说明

e,W = eigen(A) 计算 A 的特征值分解。示例

e,W = eigen(A,B) 计算 A 和 B 的广义特征值分解。示例

提示

不同电脑可能结果有差异。

# 示例

矩阵特征值

使用 gallery 创建一个对称正定矩阵。

using TyMath
A = TestArrays.lehmer(4)

A = 4×4 Matrix{Float64}:
1.0       0.5       0.333333  0.25
0.5       1.0       0.666667  0.5
0.333333  0.666667  1.0       0.75
0.25      0.5       0.75      1.0

计算 A 的特征值与左特征向量。结果为一个列向量。

e,W = eigen(A)

e = 4-element Vector{Float64}:
0.20777548591801165
0.40783288411787505
0.8482291554779121
2.5361624744861984

W = 4×4 Matrix{Float64}:
0.0693185   0.442223   0.810476  -0.377838
-0.361796   -0.74204    0.187714  -0.532206
0.769367   -0.048636  -0.300968  -0.561362
-0.521893    0.501448  -0.466165  -0.50879
矩阵特征值与特征向量
使用 gallery 创建循环矩阵。 
using TyMath
A = TestArrays.circul(3)

A = 3×3 Matrix{Float64}:
1.0  2.0  3.0
3.0  1.0  2.0
2.0  3.0  1.0

计算 A 的特征值和右特征向量。

e,W = eigen(A)

e = 3-element Vector{ComplexF64}:
 -1.4999999999999998 - 0.8660254037844386im
 -1.4999999999999998 + 0.8660254037844386im
   5.999999999999999 + 0.0im

W = 3×3 Matrix{ComplexF64}:
  0.57735-0.0im    0.57735+0.0im  -0.57735+0.0im
 -0.288675+0.5im  -0.288675-0.5im  -0.57735+0.0im
 -0.288675-0.5im  -0.288675+0.5im  -0.57735+0.0im

验证结果是否满足 。

A*W-W*diagm(e)

3×3 Matrix{ComplexF64}:
 -8.88178e-16+1.11022e-16im  -8.88178e-16-1.11022e-16im  -2.66454e-15+0.0im
          0.0-8.32667e-16im           0.0+8.32667e-16im   8.88178e-16+0.0im
 -1.16573e-15-6.66134e-16im  -1.16573e-15+6.66134e-16im  -4.44089e-16+0.0im

在理想情况下，特征值分解可满足此关系。由于 eigen 使用浮点计算执行分解，那么 可最大程度接近 。换言之， 接近但不等于 0。

广义特征值分解
using TyMath
A = [1 0; 0 -1]
B = [0 1; 1 0]

A = 2×2 Matrix{Int64}:
1   0
0  -1

B = 2×2 Matrix{Int64}:
0  1
1  0

计算 A，B 的广义特征值。

vals,vecs=eigen(A,B)

vals =
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im

vecs =
2×2 Matrix{ComplexF64}:
0.0+1.0im   0.0-1.0im
-1.0+0.0im  -1.0-0.0im
稀疏矩阵的最大特征值

使用 numgrid 函数生成一个 C 形的网格，网格大小为 15。然后使用 sparse 函数将这个网格转换为稀疏矩阵 A。

using TyMath
A = sparse(numgrid("C", 15))

15×15 SparseMatrixCSC{Int64, Int64} with 139 stored entries:
 ⋅  ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅    ⋅    ⋅    ⋅    ⋅  ⋅ 
 ⋅  1  8  15  22  30  39  49  62  75   88  101  114  127  ⋅
 ⋅  2  9  16  23  31  40  50  63  76   89  102  115  128  ⋅
 ⋮                 ⋮                    ⋮
 ⋅  ⋅  ⋅   ⋅   ⋅   ⋅   ⋅  60  73  86   99  112  125  138  ⋅
 ⋅  ⋅  ⋅   ⋅   ⋅   ⋅   ⋅  61  74  87  100  113  126  139  ⋅
 ⋅  ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅    ⋅    ⋅    ⋅    ⋅  ⋅

计算矩阵 A 的特征值。首先使用 Matrix(A) 将稀疏矩阵 A 转换为密集矩阵，然后使用 eigvals 函数计算该矩阵的所有特征值，并将结果存储在变量 eigenvalues 中。

eigenvalues = eigvals(Matrix(A))

15-element Vector{ComplexF64}:
    -10.357240665910757 + 0.0im
  -5.538563005400676e-7 + 0.0im
 -3.2743550362627056e-7 + 0.0im
                        ⋮
      9.578433637743533 + 0.0im
      81.13708844988612 + 0.0im
      728.6417185782811 + 0.0im

对特征值的绝对值进行降序排序。

sorted_eigenvalues = sort(abs.(eigenvalues),rev=true)

15-element Vector{Float64}:
 728.6417185782811
  81.13708844988612
  10.357240665910757
   ⋮
   1.1531691035153788e-14
   0.0
   0.0

从排序后的特征值中选择前六个元素，这些元素对应于绝对值最大的六个特征值。

d = sorted_eigenvalues[1:6]

6-element Vector{Float64}:
 728.6417185782811
  81.13708844988612
  10.357240665910757
   9.578433637743533
   5.538563005400676e-7
   5.538561894541123e-7
稀疏矩阵的最小特征值

使用 numgrid 函数生成一个 C 形的网格，网格大小为 15。然后使用 sparse 函数将这个网格转换为稀疏矩阵 A。

using TyMath
A = sparse(numgrid("C", 15))

15×15 SparseMatrixCSC{Int64, Int64} with 139 stored entries:
 ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅    ⋅    ⋅    ⋅    ⋅  ⋅
 ⋅  1   8  15  22  30  39  49  62  75   88  101  114  127  ⋅
 ⋅  2   9  16  23  31  40  50  63  76   89  102  115  128  ⋅
 ⋅  3  10  17  24  32  41  51  64  77   90  103  116  129  ⋅
 ⋮                  ⋮                    ⋮
 ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅  60  73  86   99  112  125  138  ⋅
 ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅  61  74  87  100  113  126  139  ⋅
 ⋅  ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅   ⋅    ⋅    ⋅    ⋅    ⋅  ⋅

计算矩阵 A 的特征值。首先使用 Matrix(A) 将稀疏矩阵 A 转换为密集矩阵，然后使用 eigvals 函数计算该矩阵的所有特征值，并将结果存储在变量 eigenvalues 中。

eigenvalues = eigvals(Matrix(A))

15-element Vector{ComplexF64}:
     -10.357240665910757 + 0.0im
   -5.538563005400676e-7 + 0.0im
  -3.2743550362627056e-7 + 0.0im
 -4.9728870760795665e-14 + 0.0im
                         ⋮
       9.578433637743533 + 0.0im
       81.13708844988612 + 0.0im
       728.6417185782811 + 0.0im

对特征值的绝对值进行升序排序。

sorted_eigenvalues = sort(abs.(eigenvalues))

15-element Vector{Float64}:
   0.0
   0.0
   1.1531691035153788e-14
   4.9728870760795665e-14
   ⋮
  10.357240665910757
  81.13708844988612
 728.6417185782811

从排序后的特征值中选择前五个元素，这些元素对应于绝对值最小的五个特征值。

d = sorted_eigenvalues[1:5]

5-element Vector{Float64}:
 0.0
 0.0
 1.1531691035153788e-14
 4.9728870760795665e-14
 5.2743513893129747e-14
使用函数句柄的特征值

创建一个 n x n 的稀疏随机矩阵 A，其中 25% 的元素是非零元素。

using TyMath
n = 1500
A = sprand(n, n, 0.25)

计算矩阵 A 的特征值。首先使用 Matrix(A) 将稀疏矩阵 A 转换为密集矩阵，然后使用 eigvals 函数计算该矩阵的所有特征值，并将结果存储在变量 eigenvalues 中。

eigenvalues = eigvals(Matrix(A))

1500-element Vector{ComplexF64}:
 -10.051606688078431 + 0.0im
   -9.95622249434315 - 0.6365923560178113im
   -9.95622249434315 + 0.6365923560178113im
  -9.794363448306058 + 0.0im
                     ⋮
    9.97811557322969 - 0.253460580360566im
    9.97811557322969 + 0.253460580360566im
  187.45702200359773 + 0.0im

对特征值的绝对值进行降序排序。

sorted_eigenvalues = sort(eigenvalues,by = abs,rev = true)

1500-element Vector{ComplexF64}:
    187.1447149726274 + 0.0im
   2.2313718239575904 - 9.925821483086793im
   2.2313718239575904 + 9.925821483086793im
   10.154542462142523 - 0.4887127710629197im
                      ⋮
 -0.18679631576146802 + 0.0im
 -0.07654274869617306 - 0.06425456535181175im
 -0.07654274869617306 + 0.06425456535181175im

从排序后的特征值中选择前六个元素，这些元素对应于绝对值最大的六个特征值。

d = sorted_eigenvalues[1:6]

6-element Vector{ComplexF64}:
 187.93325969525975 + 0.0im
 -9.488621288195198 - 3.7256610232399354im
 -9.488621288195198 + 3.7256610232399354im
  8.464207242147168 - 5.660458079356697im
  8.464207242147168 + 5.660458079356697im
  -8.50522784948005 - 5.578736984220943im
接近特征值的 Sigma 值

生成一个正方形区域的离散化 Laplace 矩阵 A。

using TyMath
A = delsq(numgrid("C", 30))
sigma = 4 - 1e-6

计算矩阵 A 的特征值，并将结果存储在 d 中。

d = eigvals(Matrix(A))

632-element Vector{Float64}:
 0.03272590611010132        
 0.06450840683841612        
 0.08455113948551246
 0.11786863816653603
 0.13468338700880186
 0.16146354080343864
 0.17732179795423764
 ⋮
 7.838536459196548
 7.865316612991188
 7.882131361833479
 7.915448860514511
 7.935491593161587
 7.967274093889902

# 输入参数

A — 输入矩阵
方阵

输入矩阵。

数据类型：Int | Float64 | Float32 | Float16

复数支持：是

B — 广义特征值问题输入矩阵
方阵

广义特征值问题输入矩阵，指定为实数值或复数值方阵。B 必须与 A 具有相同的大小。

数据类型： Int | Float64 | Float32 | Float16

复数支持： 是

# 输出参数

e — 特征值（以向量的形式返回）
向量

特征值，以包含特征值（或对组的广义特征值）的列向量及重数的形式返回。每个特征值 λ=e[k] 对应于右特征向量 v=W[:,k]。

  • 当 A 为实数对称或复数 Hermitian 矩阵时，满足 Av = λv 的 e 值为实数；
  • 当 A 为实数斜对称或复数斜 Hermitian 矩阵时，满足 Av = λv 的 e 值为虚数。
W — 右特征向量
方阵

右特征向量，作为方阵返回，其各列为 A 的右特征向量或对组 (A,B) 的广义左特征向量。W 的形式和归一化取决于输入参量的组合：

[e,W] = eig(A) 返回矩阵 W，其各列是 A 的右特征向量，这样 。W 中的特征向量已归一化，因此每个向量的 2-范数为 1。如果 A 是对称矩阵，则左特征向量与右特征向量相同。

# 另请参阅

eigvals | eigvecs | schur | cdf2rdf