WOLFRAM

Wolfram 语言与系统参考资料中心

SingularValueList[m]

给出一个矩阵 m 的非零奇异值列表.

SingularValueList[{m,a}]

给出 m 关于 a 的广义奇异值.

SingularValueList[m,k]

给出 m 的 k 个最大的奇异值.

SingularValueList[{m,a},k]

给出 m 的 k 个最大的广义奇异值.

更多信息和选项
Details and Options Details and Options
范例  
基本范例  
范围  
基本用法  
奇异值的子集  
广义奇异值  
特殊矩阵  
选项  
Tolerance  
应用  
属性和关系  
可能存在的问题  
参见
技术笔记
相关指南
历史
按以下格式引用：

SingularValueList

SingularValueList[m]

给出一个矩阵 m 的非零奇异值列表.

SingularValueList[{m,a}]

给出 m 关于 a 的广义奇异值.

SingularValueList[m,k]

给出 m 的 k 个最大的奇异值.

SingularValueList[{m,a},k]

给出 m 的 k 个最大的广义奇异值.

更多信息和选项

  • 奇异值从最大到最小排序.
  • 奇异值的多样性导致了奇异值的重复.
  • 在默认情况下，当奇异值大于10-p 的100倍时，它们会保留，其中p 是 Precision[m].
  • SingularValueList[m,Tolerance->t] 只有当大于至少 t 倍的最大奇异值时才保留.
  • SingularValueList[m,Tolerance->0] 返回所有的奇异值.
  • m 可以是矩形矩阵；全部奇异值的数目通常是 Min[Dimensions[m]].
  • 可以使用默认零误差的精确符号矩阵.
  • 奇异值可以从 Sqrt[Eigenvalues[ConjugateTranspose[m].m]] 获得.

范例

打开所有单元 关闭所有单元

基本范例  (2)

计算一个可逆矩阵的奇异值：

Wolfram Language code: SingularValueList[(| | | | - | - | | 1 | 2 | | 3 | 4 |)]

计算奇异矩阵的非零奇异值：

Wolfram Language code: SingularValueList[(⁠| | | | | - | - | - | | 1 | 2 | 3 | | 4 | 5 | 6 | | 7 | 8 | 9 |⁠)]

只有两个而非三个值，因为这是矩阵的秩：

Wolfram Language code: MatrixRank[(⁠| | | | | - | - | - | | 1 | 2 | 3 | | 4 | 5 | 6 | | 7 | 8 | 9 |⁠)]

范围  (19)

基本用法  (7)

求机器精度矩阵的非零奇异值：

Wolfram Language code: SingularValueList[(⁠| | | | | --- | --- | --- | | 1.1 | 1.3 | 2.1 | | 2.2 | 2.2 | 3.3 | | 3.3 | -3 | 4.7 |⁠)]

复矩阵的奇异值：

Wolfram Language code: SingularValueList[(⁠| | | | ----------- | ----------- | | 0.5 + 0.5 I | 1.1 | | -I | 3.2 - 4.5 I |⁠)]

精确矩阵的奇异值：

Wolfram Language code: SingularValueList[{{1, 2}, {3, 4}}]

任意精度矩阵的奇异值：

Wolfram Language code: SingularValueList[MatrixExp[RandomReal[1, {2, 2}, WorkingPrecision -> 20]]]

符号矩阵的奇异值：

Wolfram Language code: FullSimplify[SingularValueList[(⁠| | | | - | - | | a | b | | c | d |⁠)], {a, b, c, d}∈ℝ]

高效计算大型数值矩阵的奇异值：

Wolfram Language code: m = RandomReal[{1, 9}, {1000, 1000}];
Wolfram Language code: AbsoluteTiming[SingularValueList[m];]

非方阵的奇异值：

Wolfram Language code: SingularValueList[(⁠| | | | | | - | - | -- | - | | 3 | 2 | 2 | 7 | | 9 | 3 | -2 | 1 |⁠)]

奇异值的子集  (5)

求三个最大的奇异值：

Wolfram Language code: m = (⁠| | | | | | | --- | --- | ---- | ----- | ------ | | 0.5 | 0.5 | 0.5 | 0 | 0 | | 1. | 2. | 4. | 8. | 0 | | 1.5 | 4.5 | 13.5 | 40.5 | 121.5 | | 0 | 8. | 32. | 128. | 512. | | 0 | 0 | 62.5 | 312.5 | 1562.5 |⁠); SingularValueList[m, 3]

以及三个最小的奇异值：

Wolfram Language code: SingularValueList[m, -3]

求四个最大的奇异值，包括零值，或者尽可能多的奇异值（如果数量不够的话）：

Wolfram Language code: SingularValueList[(⁠| | | | | --- | --- | --- | | 0.5 | 1. | 1.5 | | 2. | 2.5 | 3. | | 3.5 | 4. | 4.5 |⁠), UpTo[4]]

计算最小奇异值时把零值奇异值：

Wolfram Language code: SingularValueList[(⁠| | | | | --- | --- | --- | | 0.5 | 1. | 1.5 | | 2. | 2.5 | 3. | | 3.5 | 4. | 4.5 |⁠), -2]

重复的奇异值多次列出：

Wolfram Language code: SingularValueList[{{2, 0, 0}, {0, 2, 0}, {0, 0, 2}}]

当提取奇异值的子集时，单独计算重复的奇异值：

Wolfram Language code: mat = {{(7/2), 0, (1/2), 0}, {0, 3, 0, 1}, {(1/2), 0, (7/2), 0}, {0, 1, 0, 3}};
Wolfram Language code: SingularValueList[mat]
Wolfram Language code: SingularValueList[mat, 3]
Wolfram Language code: SingularValueList[mat, -3]

广义奇异值  (3)

广义机器精度奇异值：

Wolfram Language code: m = {{1.5, 1.3}, {3.1, 2.2}}; a = {{1.1, 5.1}, {4.2, 3.4}}; SingularValueList[{m, a}]

求两个最小的广义奇异值：

Wolfram Language code: a = (⁠| | | | | --- | --- | --- | | 1. | 1.5 | 2. | | 3.1 | 2. | 2.9 | | 3. | 2. | 1. |⁠);b = (⁠| | | | | --- | --- | --- | | 1.3 | 0.5 | 1.1 | | 0. | 1.5 | 2.3 | | 1. | 0. | 1. |⁠);
Wolfram Language code: SingularValueList[{a, b}, -2]

求机器精度复矩阵的广义奇异值：

Wolfram Language code: m = (⁠| | | | ---------------------------------------- | ---------------------------------------- | | 4.641175490606916 + 7.207263282382337 I | 2.522671922520866 + 8.989217121399136 I | | 4.114478069008367 + 7.010706036954508 I | 8.95961276370625 + 3.569738897382109 I | | 4.405169936758572 + 4.4509297530197465 I | 9.145107926643146 + 6.3767022076415465 I |⁠);
Wolfram Language code: a = (⁠| | | | --------------------------------------- | ---------------------------------------- | | 7.341517476299638 + 9.810565178638917 I | 8.24181899398409 + 3.4570598473462972 I | | 7.775955216608212 + 1.68269060515731 I | 3.944961113408187 + 1.4889990223210265 I | | 6.431377195364613 + 6.245150387114993 I | 7.026661544586792 + 1.0790173484547747 I |⁠);
Wolfram Language code: SingularValueList[{m, a}]

特殊矩阵  (4)

稀疏矩阵的奇异值：

Wolfram Language code: SparseArray[{{1, 3} -> 2, {2, 2} -> 3, {3, 1} -> 1, {4, 2} -> 5}, {4, 4}]
Wolfram Language code: SingularValueList[%]

求三个最大的奇异值：

Wolfram Language code: SparseArray[{{x_, y_} /; Abs[x - y] < 3 -> 1}, {150, 150}]
Wolfram Language code: SingularValueList[%, 3]//FullSimplify

结构化矩阵的奇异值：

Wolfram Language code: SymmetrizedArray[{{1, 1} -> 2, {1, 2} -> 1}, {2, 2}, Symmetric[All]]
Wolfram Language code: SingularValueList[%]

使用不同结构：

Wolfram Language code: QuantityArray[{{1, 2}, {3, 4}}, {"Meters", "Meters"}]

带有单位的奇异值：

Wolfram Language code: SingularValueList[%]

IdentityMatrix 总有全为 1 的奇异值：

Wolfram Language code: SingularValueList[IdentityMatrix[12]]

HilbertMatrix 的奇异值：

Wolfram Language code: SingularValueList[HilbertMatrix[5]]//FullSimplify

选项  (2)

Tolerance  (2)

计算大于最大奇异值的 的奇异值：

Wolfram Language code: m = N[HilbertMatrix[10]];
Wolfram Language code: {Subscript[σ, 1]} = SingularValueList[m, 1];
Wolfram Language code: Select[SingularValueList[m], # > 0.1 Subscript[σ, 1]&]

设置 Tolerance 为 ，将直接计算奇异值的相同集：

Wolfram Language code: SingularValueList[m, Tolerance -> 0.1]

m 是一个 16×16希尔伯特（Hilbert) 矩阵：

Wolfram Language code: m = HilbertMatrix[16];

矩阵是正定的，有精确的算法，并带有16个非零奇异值：

Wolfram Language code: Length[SingularValueList[m]]

大多数奇异值太小以致于不能以机器精度显示：

Wolfram Language code: Length[SingularValueList[N[m]]]

设置公差为0，则将全部显示出来：

Wolfram Language code: SingularValueList[N[m], Tolerance -> 0]

因为数值误差，没有准确的计算值：

Wolfram Language code: N[SingularValueList[m]]

应用  (4)

为以下矩阵 求 TemplateBox[{{m, ., x}}, Norm]/TemplateBox[{x}, Norm] 的最大值：

Wolfram Language code: m = (⁠| | | | | ------------------- | ------------------- | ------------------ | | 0.6201924059167849 | 0.1642012623471385 | 0.9488900631268065 | | 0.45081828391187817 | 0.23528005253744255 | 0.5556683503523119 | | 0.6490685022331557 | 0.8994304255663148 | 0.4108954380673717 |⁠);

最大值等于 的最大奇异值：

Wolfram Language code: SingularValueList[m, 1]//First

使用 MaxValue 验证结果：

Wolfram Language code: MaxValue[(Norm[m.x]/Norm[x]), x∈Vectors[3, Reals]]

为以下矩阵 求服从 TemplateBox[{x}, Norm]=1 的 TemplateBox[{{m, ., x}}, Norm] 的最小值：

Wolfram Language code: m = (⁠| | | | | ------------------ | ------------------ | ------------------- | | 0.61 | 0.6596700568069829 | 0.21806383036829602 | | 0.9065034103282616 | 0.32 | 0.39008198633165536 | | 0.9749976665586482 | 0.5298619922699106 | 0.7332553638224806 |⁠);

因为矩阵的行数至少与列数一样多，所以最小值是 的最小奇异值：

Wolfram Language code: SingularValueList[m, -1]//First

使用 MinValue 验证结果：

Wolfram Language code: MinValue[Norm[m.x], x∈Sphere[]]

矩阵的算子范数，也称为谱范数或二范数，定义为 TemplateBox[{{m, ., x}}, Norm] 的最大值，其中约束条件为 TemplateBox[{x}, Norm]=1. 求以下 的算子范数：

Wolfram Language code: m = (| | | | | | - | - | - | - | | 1 | 2 | 3 | 4 | | 5 | 6 | 7 | 8 |);

TemplateBox[{{m, ., x}}, Norm] 的最大值，因此是范数，是 的最大奇异值：

Wolfram Language code: SingularValueList[m, 1]//First

使用 Norm 验证结果：

Wolfram Language code: % == Norm[m]

使用 的奇异值计算其范数、TemplateBox[{m}, Inverse] 的范数和矩阵的 条件数：

Wolfram Language code: m = (⁠| | | | | | | ------------------- | ------------------ | ------------------- | ------------------- | ------------------- | | 0.5586541141266836 | 0.4836196860997566 | 0.43001371472761707 | 0.15584341399194623 | 0.5776446005074791 | | 0.03069348146554618 | 0.5690912070366865 | 0.9683326899888793 | 0.580 | 0.5052068378482946 | | 0.6553340778639707 | 0.3059598694903798 | 0.3931179458877401 | 0.5208999887331609 | 0.27321537200542423 | | 0.03595071365286251 | 0.9210532614194069 | 0.9985000839819722 | 0.41170277644341935 | 0.3839108065740755 | | 0.5809025186735828 | 0.6117636142636071 | 0.11827188288474355 | 0.31845314947311976 | 0.35583919578557843 |⁠);

求 的奇异值：

Wolfram Language code: sv = SingularValueList[m]

矩阵的二范数等于最大奇异值：

Wolfram Language code: sv[[1]] == Norm[m, 2]

逆矩阵的二范数等于最小奇异值的倒数：

Wolfram Language code: (1/sv[[-1]])

使用 Norm 进行验证：

Wolfram Language code: % == Norm[Inverse[m], 2]

条件数是 TemplateBox[{m, 2}, Norm2] TemplateBox[{TemplateBox[{m}, Inverse, SyntaxForm -> SuperscriptBox], 2}, Norm2]，因此等于最大奇异值与最小奇异值之比：

Wolfram Language code: sv[[1]] / sv[[-1]]

属性和关系  (11)

的非零奇异值是 m.TemplateBox[{m}, ConjugateTranspose] 的非零特征值的平方根：

Wolfram Language code: m = RandomInteger[{0, 9}, {7, 5}];
Wolfram Language code: SingularValueList[m] == DeleteCases[Sqrt[Eigenvalues[m.ConjugateTranspose[m]]], 0]//FullSimplify

同样，它们是 TemplateBox[{m}, ConjugateTranspose].m 的非零特征值的平方根：

Wolfram Language code: SingularValueList[m] == DeleteCases[Sqrt[Eigenvalues[ConjugateTranspose[m].m]], 0]//FullSimplify

的完整奇异值集是 TemplateBox[{m}, ConjugateTranspose].m 或 TemplateBox[{{m, ., m}}, ConjugateTranspose] 的特征值的平方根：

Wolfram Language code: m = (⁠| | | | | - | -- | -- | | 1 | 0 | 1 | | 0 | 1 | -1 | | 1 | 1 | 0 | | 1 | -1 | 2 |⁠);
Wolfram Language code: SingularValueList[m, Tolerance -> 0]

应使用生成较小方阵的乘积，在本例中为 TemplateBox[{m}, ConjugateTranspose].m：

Wolfram Language code: % == Sqrt[Eigenvalues[ConjugateTranspose[m].m]]

生成较大方阵的阶具有额外的零特征值：

Wolfram Language code: Sqrt[Eigenvalues[m.ConjugateTranspose[m]]]

m 和 ConjugateTranspose[m] 有相同的奇异值：

Wolfram Language code: m = RandomComplex[1 + I, {5, 7}]; SingularValueList[m] == SingularValueList[ConjugateTranspose[m]]

方阵 m 的奇异值的乘积等于 Abs[Det[m]]：

Wolfram Language code: m = RandomInteger[9, {5, 5}]; Abs[Det[m]] == Times@@SingularValueList[m, Tolerance -> 0]//FullSimplify

对于正规矩阵 n，奇异值等于 Abs[Eigenvalues[n]]：

Wolfram Language code: m = {{1, 2, -1}, {-1, 1, 2}, {2, -1, 1}}; NormalMatrixQ[m]
Wolfram Language code: SingularValueList[m] == Abs[Eigenvalues[m]]

MatrixRank[m] 等于非零奇异值的数量：

Wolfram Language code: m = RandomInteger[1, {6, 6}]; MatrixRank[m] == Length[SingularValueList[m]]

TemplateBox[{m}, Inverse] 的奇异值是顺序相反的 奇异值的倒数：

Wolfram Language code: m = RandomReal[1, {5, 5}]; SingularValueList[Inverse[m]] == Reverse[(1/SingularValueList[m])]

对于 m 的子矩阵 s，m 的最大奇异值大于或等于 s 的奇异值：

Wolfram Language code: m = RandomReal[1, {5, 5}]; s = m[[RandomSample[Range[5], 3], RandomSample[Range[5], 4]]];
Wolfram Language code: First[SingularValueList[m, 1]] ≥ First[SingularValueList[s, 1]]

到 的广义奇异值等于 TemplateBox[{m}, ConjugateTranspose].m 到 TemplateBox[{a}, ConjugateTranspose].a 的广义特征值的根：

Wolfram Language code: m = RandomComplex[1 + I, {3, 3}]; a = RandomComplex[1 + I, {3, 3}];
Wolfram Language code: SingularValueList[{m, a}] == Sqrt[Eigenvalues[{ConjugateTranspose[m].m, ConjugateTranspose[a].a}]]

与普通奇异值不同，其与 TemplateBox[{{m, ., m}}, ConjugateTranspose] 到 TemplateBox[{{a, ., a}}, ConjugateTranspose] 的广义特征值无关：

Wolfram Language code: SingularValueList[{m, a}] == Sqrt[Eigenvalues[{m.ConjugateTranspose[m], a.ConjugateTranspose[a]}]]

关于 （其中 具有独立列）的最大奇异值是 max_(TemplateBox[{x}, Norm]=1)TemplateBox[{{m, ., x}}, Norm]/TemplateBox[{{a, ., x}}, Norm]：

Wolfram Language code: m = (⁠| | | | | ---- | ---- | ---- | | 0.2 | 0.05 | 0.91 | | 0.25 | 0.83 | 0.21 | | 0.2 | 0.73 | 0.43 |⁠);a = (⁠| | | | | ------------------ | ---- | ---- | | 0.01 | 0.28 | 0.63 | | 0.5700000000000001 | 0.25 | 0.63 | | 0.8 | 0.19 | 0.13 |⁠);
Wolfram Language code: SingularValueList[{m, a}]
Wolfram Language code: MaxValue[(Norm[m.x]/Norm[a.x]), x∈Sphere[]]

调用给出最大 的输入：

Wolfram Language code: v1 = ArgMax[(Norm[m.x]/Norm[a.x]), x∈Sphere[]];

第二个奇异值是比值的最大值，其约束条件为 与 为 -正交：

Wolfram Language code: MaxValue[{(Norm[m.x]/Norm[a.x]), x.a.a.v1 == 0}, x∈Sphere[]]

通过要求 与所有前面的输入 -正交，可以找到每个后续奇异值：

Wolfram Language code: v2 = ArgMax[{(Norm[m.x]/Norm[a.x]), x.a.a.v1 == 0}, x∈Sphere[]];
Wolfram Language code: MaxValue[{(Norm[m.x]/Norm[a.x]), x.a.a.v1 == 0 && x.a.a.v2 == 0}, x∈Sphere[]]

关于 的广义奇异值不同于 TemplateBox[{m}, ConjugateTranspose] 关于 TemplateBox[{a}, ConjugateTranspose] 的广义奇异值：

Wolfram Language code: m = RandomComplex[1 + I, {3, 3}]; a = RandomComplex[1 + I, {3, 3}]; SingularValueList[{m, a}] == SingularValueList[{ConjugateTranspose[m], ConjugateTranspose[a]}]

可能存在的问题  (1)

s是一个大型的稀疏矩阵：

Wolfram Language code: s = SparseArray[{{i_, i_} -> 1. / i, {1, j_} -> 1.}, {1000, 1000}]

采用线性代数计算所有的奇异值，这会让人望而却步：

Wolfram Language code: Short[SingularValueList[s]]//AbsoluteTiming

少量的计算会更快些：

Wolfram Language code: SingularValueList[s, 2]//AbsoluteTiming
Wolfram Research (2003)，SingularValueList，Wolfram 语言函数，https://reference.wolfram.com/language/ref/SingularValueList.html （更新于 2015 年）.

文本

Wolfram Research (2003)，SingularValueList，Wolfram 语言函数，https://reference.wolfram.com/language/ref/SingularValueList.html （更新于 2015 年）.

CMS

Wolfram 语言. 2003. "SingularValueList." Wolfram 语言与系统参考资料中心. Wolfram Research. 最新版本 2015. https://reference.wolfram.com/language/ref/SingularValueList.html.

APA

Wolfram 语言. (2003). SingularValueList. Wolfram 语言与系统参考资料中心. 追溯自 https://reference.wolfram.com/language/ref/SingularValueList.html 年

BibTeX

@misc{reference.wolfram_2026_singularvaluelist, author="Wolfram Research", title="{SingularValueList}", year="2015", howpublished="\url{https://reference.wolfram.com/language/ref/SingularValueList.html}", note=[Accessed: 30-October-2026]}

BibLaTeX

@online{reference.wolfram_2026_singularvaluelist, organization={Wolfram Research}, title={SingularValueList}, year={2015}, url={https://reference.wolfram.com/language/ref/SingularValueList.html}, note=[Accessed: 30-October-2026]}