线性代数
julia> A = [1 2 3; 4 1 6; 7 8 1]
3×3 Matrix{Int64}:
1 2 3
4 1 6
7 8 1
julia> tr(A)
3
julia> det(A)
104.0
julia> inv(A)
3×3 Matrix{Float64}:
-0.451923 0.211538 0.0865385
0.365385 -0.192308 0.0576923
0.240385 0.0576923 -0.0673077以及其他有用的操作，例如查找特征值或特征向量:
julia> A = [-4. -17.; 2. 2.]
2×2 Matrix{Float64}:
-4.0 -17.0
2.0 2.0
julia> eigvals(A)
2-element Vector{ComplexF64}:
-1.0 - 5.0im
-1.0 + 5.0im
julia> eigvecs(A)
2×2 Matrix{ComplexF64}:
0.945905-0.0im 0.945905+0.0im
-0.166924+0.278207im -0.166924-0.278207imjulia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
3.0 -1.0 -6.0
-10.0 2.3 4.0
julia> factorize(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
3×3 Matrix{Float64}:
1.0 0.0 0.0
-0.15 1.0 0.0
-0.3 -0.132196 1.0
U factor:
3×3 Matrix{Float64}:
-10.0 2.3 4.0
0.0 2.345 -3.4
0.0 0.0 -5.24947自 A 不是Hermitian，对称，三角形，三角形或双角形，LU因子分解可能是我们能做的最好的。 与之比较:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> factorize(B)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
3×3 Tridiagonal{Float64, Vector{Float64}}:
-1.64286 0.0 ⋅
0.0 -2.8 0.0
⋅ 0.0 5.0
U factor:
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.142857 -0.8
⋅ 1.0 -0.6
⋅ ⋅ 1.0
permutation:
3-element Vector{Int64}:
1
2
3在这里，茱莉亚发现了这一点 B 实际上是对称的，并且使用了更合适的因式分解。 通常可以为已知具有某些属性的矩阵编写更有效的代码，例如它是对称的或三边形的。 Julia提供了一些特殊类型，以便您可以将矩阵"标记"为具有这些属性。 例如:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0某人 已被标记为（实数）对称的矩阵，因此对于我们可能对其执行的后续操作，例如本征因子化或计算矩阵向量乘积，只需引用其中的一半即可找到效率。 例如:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> x = [1; 2; 3]
3-element Vector{Int64}:
1
2
3
julia> sB\x
3-element Vector{Float64}:
-1.7391304347826084
-1.1086956521739126
-1.4565217391304346该 \ 这里的操作执行线性解。 左除法运算符非常强大，很容易编写紧凑，可读的代码，足够灵活地解决各种线性方程组。
特殊矩阵
具有特殊对称性和结构的矩阵在线性代数中经常出现，并且经常与各种矩阵因子分解相关联。 Julia具有丰富的特殊矩阵类型集合，允许使用专门为特定矩阵类型开发的专用例程进行快速计算。
下表总结了已经在Julia中实现的特殊矩阵的类型，以及是否在LAPACK中为它们提供了各种优化方法的挂钩。
| 类型 | 资料描述 |
|---|---|
上,上https://en.wikipedia.org/wiki/Triangular_matrix[三角矩阵] |
|
上,上https://en.wikipedia.org/wiki/Triangular_matrix[三角矩阵]单位对角线 |
|
较低https://en.wikipedia.org/wiki/Triangular_matrix[三角矩阵] |
|
较低https://en.wikipedia.org/wiki/Triangular_matrix[三角矩阵]单位对角线 |
|
上,上https://en.wikipedia.org/wiki/Hessenberg_matrix[赫森伯格矩阵] |
|
对称三边形矩阵 |
|
|
上/下https://en.wikipedia.org/wiki/Bidiagonal_matrix[双角矩阵] |
基本操作
| 矩阵类型 | + |
- |
* |
\ |
具有优化方法的其他功能 |
|---|---|---|---|---|---|
MV |
|||||
MV |
|||||
MV |
MV |
||||
MV |
MV |
||||
MV |
MV |
||||
MV |
MV |
||||
毫米 |
|||||
M |
M |
女士 |
MV |
||
M |
M |
女士 |
MV |
||
|
M |
M |
女士 |
MV |
|
M |
M |
MV |
MV |
|
|
M |
M |
MVS |
MVS |
传说:
| 钥匙 | 资料描述 |
|---|---|
M(矩阵) |
矩阵-矩阵运算的优化方法是可用的 |
V(矢量) |
矩阵向量运算的优化方法是可用的 |
S(标量) |
矩阵标量运算的优化方法是可用的 |
矩阵因子分解
| 矩阵类型 | 拉帕克 | 本征 |
[医短节] |
eigvecs |
svd |
svdvals |
|---|---|---|---|---|---|---|
SY |
阿里 |
|||||
他 |
阿里 |
|||||
TR,TR |
A |
A |
A |
|||
TR,TR |
A |
A |
A |
|||
TR,TR |
A |
A |
A |
|||
TR,TR |
A |
A |
A |
|||
圣 |
A |
阿里 |
AV |
|||
GT;GT |
||||||
|
屋宇署 |
A |
A |
|||
迪 |
A |
传说:
| 钥匙 | 资料描述 | 例子： |
|---|---|---|
A(全部) |
找到所有特性值和/或矢量的优化方法是可用的 |
例如 |
R(范围) |
一种优化的方法来找到 |
|
I(间隔) |
求区间内特征值的优化方法[ |
|
V(向量) |
求特征值对应的特征向量的优化方法 |
|
均匀缩放运算符
A 制服,制服运算符表示标量乘以标识运算符, λ*I. 身份操作员 我 被定义为一个常数，是 制服,制服. 这些运算符的大小是通用的，并与二进制运算中的其他矩阵匹配 +, -, *和 \. 为 A+I 和 A-I 这意味着 A 必须是正方形。 与身份运算符相乘 我 是一个noop（除了检查缩放因子为一），因此几乎没有开销。
查看 制服,制服 行动中的操作员:
julia> U = UniformScaling(2);
julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> a + U
2×2 Matrix{Int64}:
3 2
3 6
julia> a * U
2×2 Matrix{Int64}:
2 4
6 8
julia> [a U]
2×4 Matrix{Int64}:
1 2 2 0
3 4 0 2
julia> b = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> b - U
ERROR: DimensionMismatch: matrix is not square: dimensions are (2, 3)
Stacktrace:
[...]如果您需要解决表单的许多系统 (A+μi)x=b 为同 A 和不同 μ，首先计算Hessenberg因子分解可能是有益的 F 的 A 通过 赫森伯格功能。 给出 F，Julia采用了一种有效的算法 (F+μ*I)\b （相当于 (A+μ*I)x\b 行列式）和相关操作。
矩阵因子分解
Matrix factorizations(a.k.a.matrix decompositions)计算矩阵的因式分解为矩阵的乘积，并且是（数值）线性代数中的中心概念之一。
下表总结了在Julia中实现的矩阵因子分解类型。 有关相关方法的详情，请参阅 标准函数部分。
| 类型 | 资料描述 |
|---|---|
|
Bunch-Kaufman因子分解 |
|
|
|
PivotedCholesky因式分解 |
|
|
|
|
|
|
|
Qr因子分解的紧凑WY形式 |
|
枢轴转动https://en.wikipedia.org/wiki/QR_decomposition[QR因子分解] |
|
QR因子分解 |
|
|
|
|
|
|
|
|
|
|
|
|
|
的邻接和换位 因式分解对象懒洋洋地包裹在 辅助因子化 和 转座因子化 物，分别。 一般地，转置实数 因式分解s被包裹为 辅助因子化.
正交矩阵（N.抽象,抽象)
一些矩阵因子分解生成正交/酉"矩阵"因子。 这些因式分解包括从调用到 资历名册，即, 资历名册, QRCompactWY 和 QRPivoted，从调用到 赫森伯格，并将lq因式分解得自 lq. 虽然这些正交/酉因素允许矩阵表示，但由于性能和内存原因，它们的内部表示是不同的。 因此，它们应该被看作是矩阵支持的，基于函数的线性算子。 特别是，读取例如其矩阵表示的列需要运行"矩阵"-向量乘法代码，而不是简单地从内存中读出数据（可能用结构零填充向量的部分）。 与其他非三角矩阵类型的另一个明显区别是，底层乘法代码允许在乘法过程中进行就地修改。 此外，具体的对象 N.抽象,抽象 通过以下方式创建的子类型 资历名册, 赫森伯格和 lq可以表现得像一个正方形或矩形矩阵取决于上下文:
julia> using LinearAlgebra
julia> Q = qr(rand(3,2)).Q
3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
julia> Matrix(Q)
3×2 Matrix{Float64}:
-0.320597 0.865734
-0.765834 -0.475694
-0.557419 0.155628
julia> Q*I
3×3 Matrix{Float64}:
-0.320597 0.865734 -0.384346
-0.765834 -0.475694 -0.432683
-0.557419 0.155628 0.815514
julia> Q*ones(2)
3-element Vector{Float64}:
0.5451367118802273
-1.241527373086654
-0.40179067589600226
julia> Q*ones(3)
3-element Vector{Float64}:
0.16079054743832022
-1.674209978965636
0.41372375588835797
julia> ones(1,2) * Q'
1×3 Matrix{Float64}:
0.545137 -1.24153 -0.401791
julia> ones(1,3) * Q'
1×3 Matrix{Float64}:
0.160791 -1.67421 0.413724由于与密集或结构化矩阵的这种区别，抽象 N.抽象,抽象 类型不子类型 [医]抽象矩阵，而是有自己的类型层次结构。 子类型的自定义类型 N.抽象,抽象 如果满足以下接口，则可以依赖通用回退。 例如，对于
struct MyQ{T} <: LinearAlgebra.AbstractQ{T}
# required fields
end提供重载
Base.size(Q::MyQ) # size of corresponding square matrix representation
Base.convert(::Type{AbstractQ{T}}, Q::MyQ) # eltype promotion [optional]
LinearAlgebra.lmul!(Q::MyQ, x::AbstractVecOrMat) # left-multiplication
LinearAlgebra.rmul!(A::AbstractMatrix, Q::MyQ) # right-multiplication如果 eltype,eltype 推广不感兴趣， 转换/转换 方法是不必要的，因为默认情况下 转换(::类型{AbstractQ{T}},Q::AbstractQ{T}) 申报表 Q 本身。 的邻接 N.抽象,抽象-类型化的对象被懒惰地包裹在一个 N.副词,副词 包装类型，它需要自己的 线性代数。lmul! 和 线性代数。rmul！ 方法。 鉴于这套方法，任何 Q::MyQ 可以像矩阵一样使用，最好在乘法上下文中：乘法通过 * 用标量、向量和矩阵从左到右，得到一个矩阵表示 Q 经 矩阵(Q) （或 Q*I）和索引到矩阵表示中的所有工作。 相反，加法和减法以及更普遍地在矩阵表示中的元素上广播失败，因为这将是非常低效的。 对于此类用例，请考虑预先计算矩阵表示并将其缓存以供将来重用。
透视策略
朱莉娅的几个 矩阵分解支持https://en.wikipedia.org/wiki/Pivot_element[枢转]，这可用于提高它们的数值稳定性。 实际上，某些矩阵因式分解（如LU因式分解）可能会在没有旋转的情况下失败。
在枢转中，首先，一个https://en.wikipedia.org/wiki/Pivot_element基于旋转策略选择具有良好数值属性的[枢轴元素]。 接下来，对原始矩阵的行和列进行排列，以使所选元素到位以供后续计算。 此外，对于因子分解的每个阶段重复该过程。
因此，除了传统的矩阵因子外，pivoted factorization方案的输出还包括置换矩阵。
在下文中，简要描述了在Julia中实现的枢转策略。 请注意，并非所有矩阵因子分解都可能支持它们。 查阅有关文件 矩阵因子分解有关支持的旋转策略的详细信息。
标准功能
Julia中的线性代数函数在很大程度上是通过从https://www.netlib.org/lapack/[LAPACK].稀疏矩阵因子分解从调用函数http://suitesparse.com[SuiteSparse].其他稀疏求解器可作为Julia包提供。
# *`基地。:*`*-Method
*(A::AbstractMatrix, B::AbstractMatrix)矩阵乘法。
*例子*
julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
2 1
1 1# *`基地。:*`*-Method
*(A, B::AbstractMatrix, C)
A * B * C * D根据数组的大小，以最有效的序列完成3或4个矩阵的链式乘法。 也就是说，所需的标量乘法的数量 (A*B)*C （具有3个密集矩阵）与用于 A*(B*C) 来选择执行其中的哪一个。
如果最后一个因子是向量，或者第一个是转置向量，那么首先处理这些是有效的。 特别是 x'*B*y 手段 (x'*B)*y 对于一个普通的列-主要 B::矩阵. 不像 点(x,B,y)，这样就分配了一个中间数组。
如果第一个或最后一个因子是一个数字，这将与矩阵乘法融合，使用5-arg 穆尔！.
|
兼容性
Julia1.7这些优化至少需要Julia1.7。 |
# *`基地。:\`*-Method
\(A, B)基质划分使用聚汞柱。 对于输入矩阵 A 和 B，结果 X 是这样的吗？ A*X==B 何时 A 是正方形的。 使用的求解器取决于 A. 如果 A 是上或下三角形（或对角线），没有因式分解 A 是必需的，系统是通过向前或向后替换来解决的。 对于非三角形方阵，使用LU因式分解。
对于矩形 A 结果是通过旋转QR因子分解计算的最小范数最小二乘解 A 和等级估计 A 基于R因子。
何时 A 是稀疏的，使用类似的聚汞合金。 对于不定矩阵， LDLt 因式分解在数值因式分解过程中不使用旋转，因此即使对于可反转矩阵，该过程也可能失败。
*例子*
julia> A = [1 0; 1 -2]; B = [32; -4];
julia> X = A \ B
2-element Vector{Float64}:
32.0
18.0
julia> A * X == B
true# *`基地。:/`*-Method
A / B矩阵右司: A/B 相当于 (B'\A')' 哪里 \是左除法运算符。 对于方阵，结果 X 是这样的吗？ A==X*B.
请参阅: rdiv！.
*例子*
julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];
julia> X = A / B
2×3 Matrix{Float64}:
-0.65 3.75 -1.2
3.25 -2.75 1.0
julia> isapprox(A, X*B)
true
julia> isapprox(X, A*pinv(B))
true# *`线性代数。SingularException`*-类型
SingularException当输入矩阵具有一个或多个零值特征值并且不可反转时引发异常。 无法计算涉及此类矩阵的线性求解。 该 资料 字段指示奇异值（s）的（之一）位置。
# *`线性代数。PosDefException`*-类型
PosDefException当输入矩阵不是时抛出异常https://en.wikipedia.org/wiki/Definiteness_of_a_matrix[正定]。 一些线性代数函数和因式分解仅适用于正定矩阵。 该 资料 字段指示小于/等于0的特征值的位置。
# *`线性代数。ZeroPivotException异常`*-类型
ZeroPivotException <: Exception当矩阵因式分解/求解在枢轴（对角线）位置遇到零并且无法继续时引发异常。 这可能意味着矩阵是奇异的：切换到不同的因式分解（如pivoted LU）可能是富有成效的，该因式分解可以重新排序变量以消除杂散零枢轴。 该 资料 字段指示零枢轴（一个）的位置。
# *`线性代数。RankDeficientException`*-类型
RankDeficientException当输入矩阵为https://en.wikipedia.org/wiki/Rank_(linear_algebra)[秩缺陷]。 一些线性代数函数，如Cholesky分解，仅适用于不存在秩缺陷的矩阵。 该 资料 字段指示矩阵的计算秩。
# *`线性代数。点`*-函数
dot(x, y)
x ⋅ y计算两个向量之间的点积。 对于复数载体，第一载体是共轭的。
点 也适用于任意可迭代对象，包括任何维度的数组，只要 点 被定义在元素上。
点 在语义上等同于 sum(点(vx,vy)for(vx,vy)in zip(x,y))，增加了参数必须具有相等长度的限制。
x＜y （哪里 ⋅ 可以通过制表符完成键入 \cdot的 在REPL中）是一个同义词 点(x,y).
*例子*
julia> dot([1; 1], [2; 3])
5
julia> dot([im; im], [1; 1])
0 - 2im
julia> dot(1:5, 2:6)
70
julia> x = fill(2., (5,5));
julia> y = fill(3., (5,5));
julia> dot(x, y)
150.0# *`线性代数。点`*-Method
dot(x, A, y)计算广义点积 点(x,A*y) 在两个向量之间 x 和 y，而不存储中间结果 A*y. 至于两个论点 点(,)，这递归地起作用。 而且，对于复数向量，第一向量是共轭的。
|
兼容性
Julia1.4三论点 |
*例子*
julia> dot([1; 1], [1 2; 3 4], [2; 3])
26
julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850
julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true# *`线性代数。交叉`*-函数
cross(x, y)
×(x,y)计算两个3向量的叉积。
*例子*
julia> a = [0;1;0]
3-element Vector{Int64}:
0
1
0
julia> b = [0;0;1]
3-element Vector{Int64}:
0
0
1
julia> cross(a,b)
3-element Vector{Int64}:
1
0
0# *`线性代数。阿克斯比！`*-函数
axpy!(α, x::AbstractArray, y::AbstractArray)复盖 y 与 x*α+y 然后回来 y. 如果 x 和 y 有相同的轴，它相当于 y.+=x．*一个.
*例子*
julia> x = [1; 2; 3];
julia> y = [4; 5; 6];
julia> axpy!(2, x, y)
3-element Vector{Int64}:
6
9
12# *`线性代数。阿克斯比！`*-函数
axpby!(α, x::AbstractArray, β, y::AbstractArray)复盖 y 与 x*α+y*β 然后回来 y. 如果 x 和 y 有相同的轴，它相当于 y.=x．*a．+y．* β.
*例子*
julia> x = [1; 2; 3];
julia> y = [4; 5; 6];
朱莉娅>axpby！(2,x,2,y)
3元素向量{Int64}:
10
14
18# *`线性代数。旋转！`*-函数
rotate!(x, y, c, s)复盖 x 与 c*x+s*y 和 y 与 -conj(s)*x+c*y. 申报表 x 和 y.
|
兼容性
朱莉娅1.5 |
# *`线性代数。反思！`*-函数
reflect!(x, y, c, s)复盖 x 与 c*x+s*y 和 y 与 conj(s)*x-c*y. 申报表 x 和 y.
|
兼容性
朱莉娅1.5 |
# *`线性代数。因式分解`*-函数
factorize(A)计算一个方便的因式分解 A，基于输入矩阵的类型。 如果 A 作为通用矩阵传递, 因式分解 检查它是否对称/三角形/等。 为此目的, 因式分解 可以检查 A 以验证/排除每个属性。 只要它可以排除对称/三角形结构，它就会短路。 返回值可以重用于多个系统的高效求解。 例如: A=因式分解(A);x=A\b;y=A\C.
的属性 A |
因式分解的类型 |
|---|---|
密集对称/Hermitian |
Bunch-Kaufman（见 |
稀疏对称/Hermitian |
LDLt（见 |
三角形 |
三角形 |
对角线 |
对角线 |
[医]双角 |
[医]双角 |
三棱角,三棱角 |
卢(见 |
对称实三角形 |
LDLt（见 |
将军广场 |
卢(见 |
一般非正方形 |
QR（见 |
*例子*
julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
1.0 1.0 0.0 0.0 0.0
0.0 1.0 1.0 0.0 0.0
0.0 0.0 1.0 1.0 0.0
0.0 0.0 0.0 1.0 1.0
0.0 0.0 0.0 0.0 1.0
julia> factorize(A) # factorize will check to see that A is already factorized
5×5 Bidiagonal{Float64, Vector{Float64}}:
1.0 1.0 ⋅ ⋅ ⋅
⋅ 1.0 1.0 ⋅ ⋅
⋅ ⋅ 1.0 1.0 ⋅
⋅ ⋅ ⋅ 1.0 1.0
⋅ ⋅ ⋅ ⋅ 1.0这返回一个 5×5双角{Float64}，现在可以传递给其他线性代数函数（例如本征求解器），这些函数将使用专门的方法 [医]双角 类型。
# *`线性代数。对角线`*-类型
Diagonal(V::AbstractVector)构造一个懒惰矩阵 V 作为其对角线。
*例子*
julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅
⋅ 10 ⋅
⋅ ⋅ 100
julia> diagm([7, 13])
2×2 Matrix{Int64}:
7 0
0 13
julia> ans + I
2×2 Matrix{Int64}:
8 0
0 14
julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
1 ⋅
⋅ 1|
注意单列矩阵不被视为向量，而是调用该方法 |
julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
7.0
13.0
julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
7.0Diagonal(A::AbstractMatrix)从主对角线构造矩阵 A. 输入矩阵 A 可能是矩形，但输出将是正方形。
*例子*
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
1 ⋅
⋅ 4
julia> A = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
1 ⋅
⋅ 5Diagonal{T}(undef, n)构造一个未初始化的 对角线{T} 长度 n. 见 unef.
# *`线性代数。[医]双角`*-类型
Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector构造一个上（u=:U）或更低（uplo=:L）使用给定对角线的bidiagonal矩阵（dv）和非对角线（电动车)向量。 结果是类型的 [医]双角 并提供高效的专门线性求解器，但可以转换成一个规则矩阵与 转换(数组,)(或 数组() 简称）。 的长度 电动车 必须比长度少一个 dv.
*例子*
julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
1
2
3
4
julia> ev = [7, 8, 9]
3-element Vector{Int64}:
7
8
9
julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 7 ⋅ ⋅
⋅ 2 8 ⋅
⋅ ⋅ 3 9
⋅ ⋅ ⋅ 4
julia>Bl=Bidiagonal(dv,ev,:L)#ev在第一个subdiagonal上
4×4双角{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
7 2 ⋅ ⋅
⋅ 8 3 ⋅
⋅ ⋅ 9 4Bidiagonal(A, uplo::Symbol)构建一个 [医]双角 矩阵从主对角线 A 而它的第一个超级-（如果 u=:U）或副对角线（如果 uplo=:L).
*例子*
julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
4×4 Matrix{Int64}:
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
julia> Bidiagonal(A, :U) # contains the main diagonal and first superdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 1 ⋅ ⋅
⋅ 2 2 ⋅
⋅ ⋅ 3 3
⋅ ⋅ ⋅ 4
julia> Bidiagonal(A, :L) # contains the main diagonal and first subdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
2 2 ⋅ ⋅
⋅ 3 3 ⋅
⋅ ⋅ 4 4# *`线性代数。SymTridiagonal缧`*-类型
SymTridiagonal(dv::V, ev::V) where V <: AbstractVector从对角线构造对称三边形矩阵（dv）和第一个子/超对角线（电动车），分别。 结果是类型的 SymTridiagonal缧 并提供高效的专门的本征解算器，但可以转换成具有 转换(数组,)(或 数组() 简称）。
为 SymTridiagonal缧 块矩阵，元素 dv 对称。 论点 电动车 被解释为超二角形。 来自细分块的块被（物化）转置相应的超细分块。
*例子*
julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
1
2
3
4
julia> ev = [7, 8, 9]
3-element Vector{Int64}:
7
8
9
朱莉娅>SymTridiagonal（dv，ev）
4×4SymTridiagonal{Int64, Vector{Int64}}:
1 7 ⋅ ⋅
7 2 8 ⋅
⋅ 8 3 9
⋅ ⋅ 9 4
julia>A=SymTridiagonal（填充([1 2; 3 4], 3), 填充([1 2; 3 4], 2));
朱莉娅>A[1,1]
2×2对称{Int64, Matrix{Int64}}:
1 2
2 4
朱莉娅>A[1,2]
2×2矩阵{Int64}:
1 2
3 4
朱莉娅>A[2,1]
2×2矩阵{Int64}:
1 3
2 4SymTridiagonal(A::AbstractMatrix)从对称矩阵的对角线和第一超二边形构造对称三边形矩阵 A.
*例子*
julia> A = [1 2 3; 2 4 5; 3 5 6]
3×3 Matrix{Int64}:
1 2 3
2 4 5
3 5 6
julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
1 2 ⋅
2 4 5
⋅ 5 6
julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);
julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
[1 2; 2 3] [1 3; 2 4]
[1 2; 3 4] [1 2; 2 3]# *`线性代数。三棱角,三棱角`*-类型
Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector分别从第一副边、对角线和第一超边构造三边矩阵。 结果是类型的 三棱角,三棱角 并提供高效的专门线性求解器，但可以转换成一个规则矩阵与 转换(数组,)(或 数组() 简称）。 的长度 dl 和 杜 必须比长度少一个 d.
|
注意细分 |
*例子*
julia> dl = [1, 2, 3];
julia> du = [4, 5, 6];
julia> d = [7, 8, 9, 0];
julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, Vector{Int64}}:
7 4 ⋅ ⋅
1 8 5 ⋅
⋅ 2 9 6
⋅ ⋅ 3 0Tridiagonal(A)从矩阵的第一子对角线、对角线和第一超对角线构造三边形矩阵 A.
*例子*
julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
4×4 Matrix{Int64}:
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
1 2 ⋅ ⋅
1 2 3 ⋅
⋅ 2 3 4
⋅ ⋅ 3 4# *`线性代数。对称`*-类型
Symmetric(A::AbstractMatrix, uplo::Symbol=:U)构建一个 对称 上视图（如果 u=:U）或更低（如果 uplo=:L)矩阵的三角形 A.
对称 视图主要用于实对称矩阵，对其启用了专门的算法（例如本征问题） 对称 类型。 更一般地说，请参阅 赫米蒂安(A)对于Hermitian矩阵 A==A'，其有效等同于 对称 对于实矩阵，但对于复杂矩阵也很有用。 （而复杂 对称 支持矩阵，但很少有专门的算法。)
计算实矩阵的对称部分，或者更一般地说是Hermitian部分 (A+A')/2 实矩阵或复数矩阵 A，使用 [医隐士].
*例子*
julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
1 2 3
4 5 6
7 8 9
julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
1 2 3
2 5 6
3 6 9
julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
1 4 7
4 5 8
7 8 9
julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
1.0 3.0 5.0
3.0 5.0 7.0
5.0 7.0 9.0请注意 晚餐 将不等于 慢一点 除非 A 本身是对称的（例如，如果 A==转置(A)).
# *`线性代数。赫米蒂安`*-类型
Hermitian(A::AbstractMatrix, uplo::Symbol=:U)构建一个 赫米蒂安 上视图（如果 u=:U）或更低（如果 uplo=:L)矩阵的三角形 A.
计算的Hermitian部分 A，使用 [医隐士].
*例子*
julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
1+0im 2+2im 3-3im
4+0im 5+0im 6-6im
7+0im 8+8im 9+0im
julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
1+0im 2+2im 3-3im
2-2im 5+0im 6-6im
3+3im 6+6im 9+0im
julia> Hlower = Hermitian(A, :L)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
1+0im 4+0im 7+0im
4+0im 5+0im 8-8im
7+0im 8+8im 9+0im
julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
1.0+0.0im 3.0+1.0im 5.0-1.5im
3.0-1.0im 5.0+0.0im 7.0-7.0im
5.0+1.5im 7.0+7.0im 9.0+0.0im请注意 胡普尔 将不等于 花椰菜 除非 A 本身是Hermitian（例如，如果 A==形容词(A)).
对角线的所有非实数部分将被忽略。
Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)# *`线性代数。低角,低角`*-类型
LowerTriangular(A::AbstractMatrix)构建一个 低角,低角 矩阵的视图 A.
*例子*
julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0
julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
1.0 ⋅ ⋅
4.0 5.0 ⋅
7.0 8.0 9.0# *`线性代数。上角,上角`*-类型
UpperTriangular(A::AbstractMatrix)构建一个 上角,上角 矩阵的视图 A.
*例子*
julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0
julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
1.0 2.0 3.0
⋅ 5.0 6.0
⋅ ⋅ 9.0# *`线性代数。N.单位角,单位角`*-类型
UnitLowerTriangular(A::AbstractMatrix)构建一个 N.单位角,单位角 矩阵的视图 A. 这样的观点具有 一个单位的 eltype,eltype的 A 在其对角线上。
*例子*
julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0
julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
1.0 ⋅ ⋅
4.0 1.0 ⋅
7.0 8.0 1.0# *`线性代数。N.单位,单位`*-类型
UnitUpperTriangular(A::AbstractMatrix)构建一个 N.单位,单位 矩阵的视图 A. 这样的观点具有 一个单位的 eltype,eltype的 A 在其对角线上。
*例子*
julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0
julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 2.0 3.0
⋅ 1.0 6.0
⋅ ⋅ 1.0# *`线性代数。上海森伯格`*-类型
UpperHessenberg(A::AbstractMatrix)构建一个 上海森伯格 矩阵的视图 A. 参赛作品 A 下面的第一个细分被忽略。
|
兼容性
Julia1.3这种类型是在Julia1.3中添加的。 |
高效的算法被实现为 H\b, 副署长(H)，和类似的。
请参阅 赫森伯格函数将任何矩阵因子化为类似的upper-Hessenberg矩阵。
如果 F::赫森伯格 是因式分解对象，酉矩阵可以用 F.Q 和赫森伯格矩阵与 F.H. 何时 Q 被提取，得到的类型是 海森伯格 对象，并可转换为具有 转换(数组,)(或 数组() 简称）。
迭代分解会产生以下因子 F.Q 和 F.H.
*例子*
julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
4×4 Matrix{Int64}:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
julia> UpperHessenberg(A)
4×4 UpperHessenberg{Int64, Matrix{Int64}}:
1 2 3 4
5 6 7 8
⋅ 10 11 12
⋅ ⋅ 15 16# *`线性代数。制服,制服`*-类型
UniformScaling{T<:Number}通用大小的统一缩放运算符定义为标量乘以标识运算符, λ*I. 虽然没有明确的 大小，它在许多情况下的作用类似于矩阵，并包括对某些索引的支持。 请参阅 我.
|
兼容性
Julia1.6使用范围的索引从Julia1.6开始可用。 |
*例子*
julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I
julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
julia> J*A
2×2 Matrix{Float64}:
2.0 4.0
6.0 8.0
julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
2.0 0.0
0.0 2.0# *`线性代数。制服,制服`*-Method
(I::UniformScaling)(n::Integer)构建一个 对角线 矩阵从a 制服,制服.
|
兼容性
Julia1.2此方法自Julia1.2起可用。 |
*例子*
julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
1 ⋅ ⋅
⋅ 1 ⋅
⋅ ⋅ 1
julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
0.7 ⋅ ⋅
⋅ 0.7 ⋅
⋅ ⋅ 0.7# *`LinearAlgebra.LU`*-类型
LU <: Factorization的矩阵因式分解类型 卢 方阵的因式分解 A. 这是返回类型 卢，对应的矩阵因式分解函数。
因式分解的各个组成部分 F::鲁 可透过 获得财产:
| 组件 | 资料描述 |
|---|---|
|
|
|
|
|
（右）排列 |
|
（右）排列 |
迭代因式分解生成组件 F.L, F.U，而 F.p.
*例子*
julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> F.L * F.U == A[F.p, :]
true
julia> l, u, p = lu(A); # destructuring via iteration
julia> l == F.L && u == F.U && p == F.p
true# *`LinearAlgebra.lu`*-函数
lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU计算稀疏矩阵的LU因子分解 A.
对于稀疏 A 使用real或complex元素类型，返回类型为 F 是 梅拢潞UmfpackLU{Tv, Ti}，与 电视 = 漂浮64或 复杂的f64 分别和 蒂 是整数类型（Int32或 Int64).
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
排列 q 可以是置换向量或 什么都没有. 如果没有提供置换向量或 q 是 什么都没有，使用UMFPACK的默认值。 如果置换不是从零开始，则进行从零开始的复制。
该 控制 vector默认为Julia SparseArrays包的UMFPACK默认配置（注意：这是从UMFPACK默认值修改为禁用迭代细化），但可以通过传递一个长度的vector来更改 UMFPACK_控制，请参阅UMFPACK手册以了解可能的配置。 例如，可重复迭代细化:
umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # read Julia default configuration for a Float64 sparse matrix
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optional - display values
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # reenable iterative refinement (2 is UMFPACK default max iterative refinement steps)
Alu = lu(A; control = umfpack_control)
x = Alu \ b # solve Ax = b, including UMFPACK iterative refinement因式分解的各个组成部分 F 可以通过索引访问:
| 组件 | 资料描述 |
|---|---|
|
|
|
|
|
右排列 |
|
左排列 |
|
|
|
|
之间的关系 F 和 A 是
F.L*F.U==(F.Rs …*A)[F.p,f.q]
F 进一步支持以下功能:
请参阅 鲁！
|
注 |
lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU计算lu因子分解 A.
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
默认情况下，与 检查=真，分解产生有效因子时也抛出错误，但上三角因子 U 是等级不足的。 这可以通过传递来改变 allowsingular=true.
在大多数情况下，如果 A 是子类型 S 的 抽象矩阵{T} 使用元素类型 T 支援服务 +, -, * 和 /，返回类型为 鲁{T,S{T}}.
一般来说，LU因式分解涉及矩阵的行的置换（对应于 F.p 输出如下所述），称为"枢轴"（因为它对应于选择哪一行包含"枢轴"，对角线条目 F.U). 可以通过可选项选择以下透视策略之一 枢轴,枢轴 论点:
* RowMaximum（） （默认值）：标准的透视策略；透视对应于剩余的、要分解的行中最大绝对值的元素。 这种透视策略要求元素类型也支持 腹肌和 <. （这通常是浮点矩阵的唯一数值稳定选项。)
* 罗农泽罗(RowNonZero)：枢轴对应于其余的第一个非零元素，要进行因式分解的行。 （这对应于手计算中的典型选择，并且对于支持的更一般的代数数类型也很有用 伊泽罗但不是 腹肌 或 <.)
* 诺皮沃特()：关闭旋转（如果在枢轴位置遇到零条目，即使在 allowsingular=true).
因式分解的各个组成部分 F 可透过 获得财产:
| 组件 | 资料描述 |
|---|---|
|
|
|
|
|
（右）排列 |
|
（右）排列 |
迭代因式分解生成组件 F.L, F.U，而 F.p.
之间的关系 F 和 A 是
F.L*F.U==A[F.p,:]
F 进一步支持以下功能:
| 支持的功能 | 卢 |
鲁{T,Tridiagonal{T}} |
|---|---|---|
✓ |
||
✓ |
✓ |
|
✓ |
✓ |
|
✓ |
✓ |
|
✓ |
✓ |
|
✓ |
✓ |
|
✓ |
✓ |
|
兼容性
朱莉娅1.11 |
*例子*
julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> F.L * F.U == A[F.p, :]
true
julia> l, u, p = lu(A); # destructuring via iteration
julia> l == F.L && u == F.U && p == F.p
true
julia>lu([1 2;1 2],allowsingular=true)
卢{Float64, Matrix{Float64}，向量{Int64}}
L因子:
2×2矩阵{Float64}:
1.0 0.0
1.0 1.0
U因子（rank-deficient）:
2×2矩阵{Float64}:
1.0 2.0
0.0 0.0# *`LinearAlgebra.lu！`*-函数
lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU计算稀疏矩阵的LU因子分解 A，重用存储在已存在的LU因式分解的符号因式分解 F. 除非 [医]杂音 被设置为false，稀疏矩阵 A 必须具有与用于创建LU因子分解的矩阵相同的非零模式 F，否则抛出错误。 如果大小 A 和 F 不同，所有向量将相应调整大小。
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
排列 q 可以是置换向量或 什么都没有. 如果没有提供置换向量或 q 是 什么都没有，使用UMFPACK的默认值。 如果置换不是基于零，则进行基于零的复制。
请参阅 卢
|
注 |
|
兼容性
朱莉娅1.5 |
*例子*
julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);
julia> F = lu(A);
julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);
julia> lu!(F, B);
朱莉娅>f\ones(2)
2元素向量{Float64}:
0.0
1.0lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU|
兼容性
朱莉娅1.11 |
*例子*
julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
4.0 3.0
6.0 3.0
julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> iA = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]# *`线性代数。乔莱斯基`*-类型
Cholesky <: Factorization密对称/Hermitian正定矩阵的Cholesky因式分解的矩阵因式分解类型 A. 这是返回类型 乔莱斯基，对应的矩阵因式分解函数。
三角Cholesky因子可以从因子分解得到 F::Cholesky 经 F.L 和 F.U，在哪里 A≈F.U'*F.U≈F.L*F.L'.
迭代分解生成组件 L 和 U.
*例子*
julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
4.0 12.0 -16.0
12.0 37.0 -43.0
-16.0 -43.0 98.0
julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
2.0 6.0 -8.0
⋅ 1.0 5.0
⋅ ⋅ 3.0
julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
2.0 6.0 -8.0
⋅ 1.0 5.0
⋅ ⋅ 3.0
julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
2.0 ⋅ ⋅
6.0 1.0 ⋅
-8.0 5.0 3.0
julia> C.L * C.U == A
true
julia> l, u = C; # destructuring via iteration
julia> l == C.L && u == C.U
true# *`线性代数。[医]胆小鬼`*-类型
CholeskyPivoted密对称/Hermitian正半定矩阵的枢转Cholesky因式分解的矩阵因式分解类型 A. 这是返回类型 cholesky(_,::RowMaximum)，对应的矩阵因式分解函数。
三角Cholesky因子可以从因子分解得到 F::CholeskyPivoted 经 F.L 和 F.U，以及通过 F.p，在哪里 A[F.p,F.p]≈Ur'*Ur≈Lr*Lr' 与 Ur=F.U[1：f.rank，：] 和 Lr=F.L[:,1:F.rank]，或替代地 A≈Up'*Up≈Lp*Lp' 与 Up=F.U[1：f.rank，invperm（F.p）] 和 Lp=F.L[invperm（F.p），1：F.rank].
迭代分解生成组件 L 和 U.
*例子*
julia> X = [1.0, 2.0, 3.0, 4.0];
julia> A = X * X';
julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
4.0 2.0 3.0 1.0
⋅ 0.0 6.0 2.0
⋅ ⋅ 9.0 3.0
⋅ ⋅ ⋅ 1.0
permutation:
4-element Vector{Int64}:
4
2
3
1
julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true
julia> l, u = C; # destructuring via iteration
julia> l == C.L && u == C.U
true# *`线性代数。乔莱斯基`*-函数
cholesky(A, NoPivot(); check = true) -> Cholesky计算密集对称正定矩阵的Cholesky因式分解 A 并返回一个 乔莱斯基因式分解。 矩阵 A 可以是一个 对称或 赫米香 [医抽象矩阵]或_perfectly_对称或Hermitian [医]抽象矩阵.
三角Cholesky因子可以从因子分解得到 F 经 F.L 和 F.U，在哪里 A≈F.U'*F.U≈F.L*F.L'.
如果你有一个矩阵 A 由于其构造中的舍入错误，这有点非Hermitian，将其包裹在 赫米蒂安(A) 在传递给 乔莱斯基 为了把它当作完美的隐士。
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
*例子*
julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
4.0 12.0 -16.0
12.0 37.0 -43.0
-16.0 -43.0 98.0
julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
2.0 6.0 -8.0
⋅ 1.0 5.0
⋅ ⋅ 3.0
julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
2.0 6.0 -8.0
⋅ 1.0 5.0
⋅ ⋅ 3.0
julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
2.0 ⋅ ⋅
6.0 1.0 ⋅
-8.0 5.0 3.0
julia> C.L * C.U == A
truecholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted计算密集对称正半定矩阵的枢转Cholesky因式分解 A 并返回一个 [医胆小鬼]因式分解。 矩阵 A 可以是一个 对称或 赫米香 [医抽象矩阵]或_perfectly_对称或Hermitian [医]抽象矩阵.
三角Cholesky因子可以从因子分解得到 F 经 F.L 和 F.U，以及通过 F.p，在哪里 A[F.p,F.p]≈Ur'*Ur≈Lr*Lr' 与 Ur=F.U[1：f.rank，：] 和 Lr=F.L[:,1:F.rank]，或另选地 A≈Up'*Up≈Lp*Lp' 与 Up=F.U[1:f.rank,invperm(F.p)] 和 Lp=F.L[invperm（F.p），1：F.rank].
论点 托尔 确定用于确定秩的容差。 对于负值，容差等于 eps()*尺寸(A,1)*最大(diag(A)).
如果你有一个矩阵 A 由于其构造中的舍入错误，这有点非Hermitian，将其包裹在 赫米蒂安(A) 在传递给 乔莱斯基 为了把它当作完美的隐士。
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
*例子*
julia> X = [1.0, 2.0, 3.0, 4.0];
julia>A=X*X';
julia>C=cholesky（A，RowMaximum（），check=false）
[医]胆小鬼{Float64, Matrix{Float64}，向量{Int64}}
排名1的U因子:
4×4上方角{Float64, Matrix{Float64}}:
4.0 2.0 3.0 1.0
⋅ 0.0 6.0 2.0
⋅ ⋅ 9.0 3.0
⋅ ⋅ ⋅ 1.0
排列,排列:
4元素向量{Int64}:
4
2
3
1
julia>C.U[1:c.rank,:]'*C.U[1:c.rank,:]≈A[C.p,C.p]
真的
julia>l,u=c;#通过迭代解构
julia>l==C.L&&u==C.U
真的cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor计算稀疏正定矩阵的Cholesky因式分解 A. A 必须是一个 [医麻雀]或一个 对称/赫米香查看a [医]麻雀. 请注意，即使 A 没有类型标签，它仍然必须是对称的或隐密的。 如果 烫发,烫发 没有给出，使用填充减少置换。 F=cholesky（A） 最常用于求解方程组 F\b，而且方法 迪亚格, 德特，和 logdet,logdet被定义为 F. 您还可以从 F，使用 F.L. 但是，由于默认情况下透视是打开的，因此因子分解在内部表示为 A==P'*L*L'*P 用置换矩阵 P;使用just L 不考虑 P 会给出不正确的答案。 要包括置换的影响，通常优选提取"组合"因子，例如 PtL=F.PtL （相当于 P'*L)和 LtP=F.向上 （相当于 L'*P).
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
设置可选项 轮班 关键字参数计算 A+shift*I 而不是 A. 如果 烫发,烫发 提供了参数，它应该是一个置换 1:尺寸(A,1) 给出要使用的排序（而不是CHOLMOD的默认AMD排序）。
请参阅 ldlt对于不需要正定义的类似因式分解，但可以显着慢于 乔莱斯基.
*例子*
在下面的示例中，使用的填充减少置换是 [3, 2, 1]. 如果 烫发,烫发 被设置为 1:3 要强制执行无置换，因子中的非零元素数为6。
julia> A = [2 1 1; 1 2 0; 1 0 2]
3×3 Matrix{Int64}:
2 1 1
1 2 0
1 0 2
julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type: LLt
method: simplicial
maxnnz: 5
nnz: 5
success: true
julia> C.p
3-element Vector{Int64}:
3
2
1
julia> L = sparse(C.L);
朱莉娅>矩阵(L)
3×3矩阵{Float64}:
1.41421 0.0 0.0
0.0 1.41421 0.0
0.707107 0.707107 1.0
julia>L*L'≈A[C.p,C.p]
真的
julia>P=稀疏（1：3，C.p，ones（3））
3×3SparseMatrixCSC{Float64, Int64} 与3个存储的条目:
⋅ ⋅ 1.0
⋅ 1.0 ⋅
1.0 ⋅ ⋅
julia>P'*L*L'*P≈A
真的
julia>C=cholesky（稀疏（A），烫发=1：3）
麻雀。霍莫德。因素{Float64, Int64}
类型：LLt
方法：简单
maxnnz：6
nnz：6
成功：真实
julia>L=稀疏（C.L）;
朱莉娅>矩阵(L)
3×3矩阵{Float64}:
1.41421 0.0 0.0
0.707107 1.22474 0.0
0.707107 -0.408248 1.1547
朱莉娅>L*L'≈A
真的来自CHOLMOD的许多其他函数被包装，但没有从 `基地。麻雀。霍莫德` 模块。
# *`线性代数。切尔斯基！`*-函数
cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky*例子*
julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
1 2
2 50
julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivotedcholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor请参阅 乔莱斯基.
|
注意此方法使用SuiteSparse的CHOLMOD库，该库仅支持单精度或双精度的实数或复杂类型。 不属于这些元素类型的输入矩阵将根据需要转换为这些类型。 |
# *`线性代数。[医]低档日期`*-函数
lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky更新一个Cholesky因子分解 C 与向量 v. 如果 A=C.U’C.U 然后 CC=cholesky(C.U’C.U+v*v') 但计算 CC脦陋胫茫 只使用 O(n^2) 行动。
lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor得到一个 LDLt 因式分解 A+C*C' 给定一个 LDLt 或 [医]LLt 因式分解 F 的 A.
返回的因子始终为 LDLt 因式分解。
请参阅 lowrankupdate！, 低档日期, lowrankdowndate！.
# *`线性代数。低档日期`*-函数
lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::CholeskyDowndate一个Cholesky因子分解 C 与向量 v. 如果 A=C.U’C.U 然后 CC=cholesky(C.U’C.U-v*v') 但计算 CC脦陋胫茫 只使用 O(n^2) 行动。
lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor得到一个 LDLt 因式分解 A+C*C' 给定一个 LDLt 或 [医]有限责任公司 因式分解 F 的 A.
返回的因子始终为 LDLt 因式分解。
请参阅 lowrankdowndate！, [医低档日期], lowrankupdate！.
# *`线性代数。lowrankupdate！`*-函数
lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky更新一个Cholesky因子分解 C 与向量 v. 如果 A=C.U’C.U 然后 CC=cholesky（C.U’C.U+v*v'） 但计算 CC脦陋胫茫 只使用 O(n^2) 行动。 输入因子分解 C 更新到位，以便在退出时 C==CC. 向量 v 在计算过程中被销毁。
lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)更新一个 LDLt 或 [医]有限责任公司 因式分解 F 的 A 对…… A+C*C'.
[医]有限责任公司 因式分解转换为 LDLt.
请参阅 [医低档日期], 低档日期, lowrankdowndate！.
# *`线性代数。lowrankdowndate！`*-函数
lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::CholeskyDowndate一个Cholesky因子分解 C 与向量 v. 如果 A=C.U’C.U 然后 CC=cholesky(C.U’C.U-v*v') 但计算 CC脦陋胫茫 只使用 O(n^2) 行动。 输入因子分解 C 更新到位，以便在退出时 C==CC. 向量 v 在计算过程中被销毁。
lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)更新一个 LDLt 或 [医]有限责任公司 因式分解 F 的 A 对…… A-C*C'.
[医]有限责任公司 因式分解转换为 LDLt.
请参阅 低档日期, [医低档日期], lowrankupdate！.
# *`线性代数。LDLt`*-类型
LDLt <: Factorization的矩阵因式分解类型 LDLt 实数的因式分解 SymTridiagonal缧矩阵 S 这样， S=L*对角线(d)*L'，在哪里 L 是一个 N.单位角,单位角矩阵和 d 是一个向量。 主要用途是 LDLt 因式分解 F=ldlt（S） 是求解线性方程组 Sx=b 与 F\b. 这是返回类型 ldlt，对应的矩阵因式分解函数。
因式分解的各个组成部分 F::LDLt 可透过 获得财产:
| 组件 | 资料描述 |
|---|---|
|
|
|
|
|
|
|
的对角线值 |
*例子*
julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
3.0 1.0 ⋅
1.0 4.0 2.0
⋅ 2.0 5.0
julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
1.0 ⋅ ⋅
0.333333 1.0 ⋅
0.0 0.545455 1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
3.0 ⋅ ⋅
⋅ 3.66667 ⋅
⋅ ⋅ 3.90909# *`线性代数。ldlt`*-函数
ldlt(S::SymTridiagonal) -> LDLt计算一个 LDLt （即, )实对称三边形矩阵的因式分解 S 这样， S=L*对角线(d)*L' 哪里 L 是单位下三角矩阵和 d 是一个向量。 主要用途是 LDLt 因式分解 F=ldlt（S） 是求解线性方程组 Sx=b 与 F\b.
请参阅 邦奇考夫曼对于任意对称或Hermitian矩阵的类似但枢转的因式分解。
*例子*
julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
3.0 1.0 ⋅
1.0 4.0 2.0
⋅ 2.0 5.0
julia> ldltS = ldlt(S);
julia> b = [6., 7., 8.];
julia> ldltS \ b
3-element Vector{Float64}:
1.7906976744186047
0.627906976744186
1.3488372093023255
julia> S \ b
3-element Vector{Float64}:
1.7906976744186047
0.627906976744186
1.3488372093023255ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor计算 稀疏矩阵的因式分解 A. A 必须是一个 [医麻雀]或一个 对称/赫米香查看a [医]麻雀. 请注意，即使 A 没有类型标签，它仍然必须是对称的或隐密的。 使用填充减少置换。 F=ldlt（A） 最常用于求解方程组 A*x=b 与 F\b. 返回的因式分解对象 F 也支持这些方法 迪亚格, 德特, logdet,logdet，和 因维. 您可以从 F 使用 F.L. 但是，由于默认情况下透视是打开的，因此因子分解在内部表示为 A==P'*L*D*L'*P 用置换矩阵 P;使用just L 不考虑 P 会给出不正确的答案。 为了包括置换的影响，通常优选提取"组合"因子，如 PtL=F.PtL （相当于 P'*L)和 LtP=F.向上 （相当于 L'*P). 支持的因素的完整列表是 :L,:PtL,:D,:UP,:U,:LD,:DU,:PtLD,:DUP.
与相关的Cholesky因子分解不同， 因式分解不需要 A 是肯定的。 然而，它仍然要求所有主要未成年人都有良好的条件，如果不满足，就会失败。
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
设置可选项 轮班 关键字参数计算 A+shift*I 而不是 A. 如果 烫发,烫发 提供了参数，它应该是一个置换 1:尺寸(A,1) 给出要使用的排序（而不是CHOLMOD的默认AMD排序）。
请参阅 乔莱斯基对于一个可以显着快于 ldlt，但要求 A 是肯定的。
来自CHOLMOD的许多其他函数被包装，但没有从 `基地。麻雀。霍莫德` 模块。
# *`线性代数。ldlt！`*-函数
ldlt!(S::SymTridiagonal) -> LDLt同为 ldlt，但通过复盖输入来节省空间 S，而不是创建副本。
*例子*
julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
3.0 1.0 ⋅
1.0 4.0 2.0
⋅ 2.0 5.0
julia> ldltS = ldlt!(S);
julia> ldltS === S
false
julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
3.0 0.333333 ⋅
0.333333 3.66667 0.545455
⋅ 0.545455 3.90909ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor请参阅 ldlt.
|
注意此方法使用CHOLMOD库从https://github.com/DrTimothyAldenDavis/SuiteSparse[SuiteSparse]，仅支持单精度或双精度的实数或复杂类型。 不属于这些元素类型的输入矩阵将根据需要转换为这些类型。 |
# *`线性代数。QRCompactWY`*-类型
QRCompactWY <: Factorization以紧凑的阻塞格式存储的QR矩阵因子分解，通常从 资历名册. 如果 是一个 m×n 矩阵，则
哪里 是正交/酉矩阵和 是上三角形。 它类似于 资历名册格式除了正交/酉矩阵 被存储在_Compact WY_格式脚注:Schreiber1989[R Schreiber和C Van Loan,"a storage-efficient wy representation for products of Householder transformations",SIAM J Sci Stat Comput10(1989),53-57. doi:10.1137/0910005].对于块大小 ，它被存储为一个 m×n 下梯形矩阵 和矩阵 由 上三角矩阵 大小 ×＝n_b＝( )和上梯形 ×÷\min(m,n)-(b-1)n_b÷矩阵 ( )其上方形部分以 令人满意
这样， 是 第三栏 , 是 第三要素 [diag(T_1);diag(T_2);…;diag(T_b)]，而 是左 m×最小(m,n) 的块 . 当使用 资历名册，块大小由下式给出 .
迭代分解生成组件 Q 和 R.
对象有两个字段:
* 因素，如在 资历名册类型，是一个 m×n 矩阵。
**上部三角形部分包含的元素 ，即 R=triu（F.因素） 对于一个 资历名册 对象 F.
**细分部分包含反射器 以打包格式存储，以便 V=I+tril(F.因子，-1).
* T 是一个 -按-$\min(m,n)matrix矩阵如上所述。 每个三角形矩阵的细分元素 被忽略。
|
注意此格式不应与较旧的_WY_表示脚注混淆：Bischof1987[C Bischof和C Van Loan，"The WY representation for products of Householder matrices"，SIAM J Sci Stat Comput8（1987），s2-s13。 doi：10.1137/0908009]。 |
# *`线性代数。QRPivoted`*-类型
QRPivoted <: Factorization以填充格式进行列旋转的QR矩阵因子分解，通常从 资历名册. 如果 是一个 m×n 矩阵，则
哪里 是置换矩阵, 是正交/酉矩阵和 是上三角形。 矩阵 存储为户主反射器的序列:
迭代分解生成组件 Q, R，而 p.
对象有三个字段:
* 因素 是一个 m×n 矩阵。
**上部三角形部分包含的元素 ，即 R=triu（F.因素） 对于一个 资历名册 对象 F.
**细分部分包含反射器 以打包格式存储， 是 矩阵的第th列 V=I+tril(F.因子，-1).
* τ 是长度的向量 最小(m,n) 包含系数 .
* jpvt 是长度的整数向量 n 对应于置换 .
# *`线性代数。资历名册`*-函数
qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse计算 资历名册 稀疏矩阵的因式分解 A. 使用减少填充的行和列排列，以便 F.R=F.Q'*A[F.prow,f.pcol]. 这种类型的主要应用是解决最小二乘或欠定问题 \. 函数调用C库SPQR[3]。
|
注 |
*例子*
julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
1.0 ⋅
1.0 ⋅
⋅ 1.0
⋅ 1.0
julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
-1.41421 ⋅
⋅ -1.41421
Row permutation:
4-element Vector{Int64}:
1
3
4
2
Column permutation:
2-element Vector{Int64}:
1
2qr(A, pivot = NoPivot(); blocksize) -> F计算矩阵的QR因子分解 A：正交（或酉if A 是复数值）矩阵 Q，以及上三角矩阵 R 这样，
返回的对象 F 以打包格式存储因子分解:
*如果 枢轴==ColumnNorm（） 然后 F 是一个 QRPivoted对象,
*否则，如果元素类型为 A 是BLAS类型（漂浮物32, 漂浮64, 复杂的32 或 复杂的f64），则 F 是一个 QRCompactWY对象,
*否则 F 是一个 资历名册对象。
分解的各个组成部分 F 可以通过属性访问器检索:
|
注意每个参考上三角因子通过 |
迭代分解生成组件 Q, R，如果现存 p.
以下功能可用于 资历名册 对象: 因维, 大小，和 \. 何时 A 为矩形, \ 将返回一个最小二乘解，如果解不是唯一的，则返回范数最小的解。 何时 A 如果不是满秩，则需要使用（列）旋转进行因式分解以获得最小范数解。
关于满/平方或非满/平方的乘法 Q 是允许的，即两者兼而有之 F.Q*F.R 和 F.Q*A 得到支持。 A Q 矩阵可以转换成一个有规律的矩阵 矩阵. 此操作返回"瘦"Q因子，即，如果 A 是 m×n 与 m>=n，则 矩阵(F.Q) 产生一个 m×n 正交列的矩阵。 要检索"完整"Q因子， m×m 正交矩阵，使用 F.Q*I 或 收集(F.Q). 如果 m<=n，则 矩阵(F.Q) 产生一个 m×m 正交矩阵。
QR分解的块大小可以通过关键字参数指定 块大小:整数 何时 枢轴==NoPivot（） 和 一个isa StridedMatrix{<:BlasFloat}. 它被忽略时 区块大小>最小(大小(A)). 见 QRCompactWY.
|
兼容性
朱莉娅1.4 |
*例子*
julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
3.0 -6.0
4.0 -8.0
0.0 1.0
julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
-5.0 10.0
0.0 -1.0
julia> F.Q * F.R == A
true|
注 |
# *`线性代数。qr！`*-函数
qr!(A, pivot = NoPivot(); blocksize)qr！ 是一样的 资历名册当 A 是 [医抽象矩阵]，但通过复盖输入来节省空间 A，而不是创建副本。 一个 N.恐怖,恐怖如果因式分解产生一个不能由元素类型表示的数字，则抛出异常 A，例如对于整数类型。
|
兼容性
朱莉娅1.4 |
*例子*
julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
-3.16228 -4.42719
0.0 -0.632456
julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]# *`线性代数。LQ`*-类型
LQ <: Factorization如果 S::LQ 是因式分解对象，下三角分量可通过 S.L，和正交/酉分量通过 S.Q，这样 A≈S.L*S.Q.
迭代分解生成组件 S.L 和 S.Q.
*例子*
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
-8.60233 0.0
4.41741 -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
julia> S.L * S.Q
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia>l,q=S;#通过迭代解构
julia>l==S.L&&q==S.Q
真的# *`线性代数。lq`*-函数
lq(A) -> S::LQ计算lq分解 A. 分解的下三角分量可以从 LQ对象 S 经 S.L，和正交/酉分量通过 S.Q，这样 A≈S.L*S.Q.
迭代分解生成组件 S.L 和 S.Q.
LQ分解是QR分解 转置(A)，并且它是有用的，以便计算最小范数解 lq(A)\b 到欠定方程组（A 具有比行更多的列，但具有完整的行秩）。
*例子*
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
-8.60233 0.0
4.41741 -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
julia> S.L * S.Q
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> l, q = S; # destructuring via iteration
julia> l == S.L && q == S.Q
true# *`线性代数。邦奇考夫曼`*-类型
BunchKaufman <: Factorization束的矩阵因式分解类型-对称矩阵或Hermitian矩阵的考夫曼因式分解 A 作为 P’UDU’P 或 P’LL’P，取决于上部（默认）还是下部三角形存储在 A. 如果 A 那么是复数对称的 U' 和 L' 表示未结合的转座，即 转置(U) 和 转置(L)，分别。 这是返回类型 邦奇考夫曼，对应的矩阵因式分解函数。
如果 S::BunchKaufman 是因式分解对象，分量可以通过 S.D., 美国 或 S.L 视情况而定 S.上升，而 S.p.
迭代分解生成组件 S.D., 美国 或 S.L 视情况而定 S.上升，而 S.p.
*例子*
julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
1.0 2.0
2.0 3.0
julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
-0.333333 0.0
0.0 3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.666667
⋅ 1.0
permutation:
2-element Vector{Int64}:
1
2
julia> d, u, p = S; # destructuring via iteration
julia> d == S.D && u == S.U && p == S.p
true
julia>S=bunchkaufman（对称（A，：L））
邦奇考夫曼{Float64, Matrix{Float64}，向量{Int64}}
D因子:
2×2三角形{Float64, Vector{Float64}}:
3.0 0.0
0.0 -0.333333
L因子:
2×2单位角{Float64, Matrix{Float64}}:
1.0 ⋅
0.666667 1.0
排列,排列:
2元素向量{Int64}:
2
1# *`线性代数。邦奇考夫曼`*-函数
bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufmanCompute The Bunch-Kaufman脚注：Bunch1977[J R Bunch and L Kaufman,Some stable methods for calculation inertia and solving symmetric linear systems,Mathematics of Computation31:137(1977),163-179. url.]对称或Hermitian矩阵的因式分解 A 作为 P'*U*D*U'*P 或 P'*L*D*L'*P，取决于存储在哪个三角形 A，并返回一个 邦奇考夫曼对象。 请注意，如果 A 那么是复数对称的 U' 和 L' 表示未结合的转座，即 转置(U) 和 转置(L).
迭代分解生成组件 S.D., 美国 或 S.L 视情况而定 S.上升，而 S.p.
如果 鲁克 是 真的，使用了旋转。 如果 鲁克 为false，则不使用旋转。
何时 检查=真，分解失败则抛出错误。 何时 检查=错误，负责检查分解的有效性（通过 伊斯成功）在于用户。
以下功能可用于 邦奇考夫曼 对象: 大小, \, 因维, issymmetric碌录潞陆, 伊瑟米香, getindex,getindex.
*例子*
julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
1.0 2.0
2.0 3.0
julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
-0.333333 0.0
0.0 3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.666667
⋅ 1.0
permutation:
2-element Vector{Int64}:
1
2
julia> d, u, p = S; # destructuring via iteration
julia> d == S.D && u == S.U && p == S.p
true
julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
0.0 0.0
0.0 0.0
julia>S=bunchkaufman（对称（A，：L））
邦奇考夫曼{Float64, Matrix{Float64}，向量{Int64}}
D因子:
2×2三角形{Float64, Vector{Float64}}:
3.0 0.0
0.0 -0.333333
L因子:
2×2单位角{Float64, Matrix{Float64}}:
1.0 ⋅
0.666667 1.0
排列,排列:
2元素向量{Int64}:
2
1
julia>S.L*S.D*S.L'-A[S.p,S.p]
2×2矩阵{Float64}:
0.0 0.0
0.0 0.0# *`线性代数。本征`*-类型
Eigen <: Factorization方阵的特征值/频谱分解的矩阵因式分解类型 A. 这是返回类型 本征，对应的矩阵因式分解函数。
如果 F::本征 是因式分解对象，特征值可以通过 F.价值观 和特征向量作为矩阵的列 F.向量. （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
*例子*
julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
1.0
3.0
18.0
vectors:
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
朱莉娅>F.价值观
3元素向量{Float64}:
1.0
3.0
18.0
julia>f.向量
3×3矩阵{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia>vals,vecs=F;#通过迭代解构
julia>vals==F.values&&vecs==f.vectors
真的# *`线性代数。[医]将军`*-类型
GeneralizedEigen <: Factorization广义特征值/频谱分解的矩阵因式分解类型 A 和 B. 这是返回类型 本征，相应的矩阵因式分解函数，当用两个矩阵参数调用时。
如果 F::一般化 是因式分解对象，特征值可以通过 F.价值观 和特征向量作为矩阵的列 F.向量. （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
*例子*
julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
1 0
0 -1
julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
0 1
1 0
julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
0.0+1.0im 0.0-1.0im
-1.0+0.0im -1.0-0.0im
julia> F.values
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im
julia>f.向量
2×2矩阵{ComplexF64}:
0.0+1.0im0.0-1.0im
-1.0+0.0im-1.0-0.0im
julia>vals,vecs=F;#通过迭代解构
julia>vals==F.values&&vecs==f.vectors
真的# *`线性代数。[医]短节`*-函数
eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values返回的特征值 A.
对于一般的非对称矩阵，可以在特征值计算之前指定矩阵的平衡方式。 该 排列,排列, 比例尺，而 索特比 关键字与for相同 本征.
*例子*
julia> diag_matrix = [1 0; 0 4]
2×2 Matrix{Int64}:
1 0
0 4
julia> eigvals(diag_matrix)
2-element Vector{Float64}:
1.0
4.0对于标量输入, [医]短节 会返回一个标量。
*例子*
julia> eigvals(-2)
-2eigvals(A, B) -> values计算广义特征值 A 和 B.
*例子*
julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
1 0
0 -1
julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
0 1
1 0
julia> eigvals(A,B)
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0imeigvals(A::Union{Hermitian, Symmetric}; alg::Algorithm = default_eigen_alg(A))) -> values返回的特征值 A.
阿尔格 指定用于特征值分解的算法和LAPACK方法:
* alg=DivideAndConquer（）：电话 拉帕克。赛夫德！.
* alg=QRIteration（）：电话 拉帕克。赛耶夫！.
* alg=鲁棒代表() （默认）：多个相对健壮的表示方法，调用 拉帕克。syevr！.
参见James W.Demmel等，SIAM J.Sci. 康普特。 30,3,1508(2008)用于比较不同方法的准确性和性能。
默认值 阿尔格 使用可能会在未来发生变化。
|
兼容性
朱莉娅1.12 |
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values返回的特征值 A. 可以通过指定一个 单位范围 伊兰奇 复盖已排序特征值的索引，例如第2至第8个特征值。
*例子*
julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
1.0 2.0 ⋅
2.0 2.0 3.0
⋅ 3.0 1.0
朱莉娅>eigvals（A，2：2）
1元素向量{Float64}:
0.9999999999999996
朱莉娅>eigvals(一)
3元素向量{Float64}:
-2.1400549446402604
1.0000000000000002
5.140054944640259eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values返回的特征值 A. 可以通过指定一对来仅计算特征值的子集 vl 和 vu 为特征值的下边界和上边界。
*例子*
julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
1.0 2.0 ⋅
2.0 2.0 3.0
⋅ 3.0 1.0
julia> eigvals(A, -1, 2)
1-element Vector{Float64}:
1.0000000000000009
julia> eigvals(A)
3-element Vector{Float64}:
-2.1400549446402604
1.0000000000000002
5.140054944640259# *`线性代数。eigvals！`*-函数
eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values|
注意输入矩阵 |
*例子*
julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
朱莉娅>eigvals！(一)
2元素向量{Float64}:
-0.3722813232690143
5.372281323269014
朱莉娅>A
2×2矩阵{Float64}:
-0.372281 -1.0
0.0 5.37228eigvals!(A, B; sortby) -> values同为 [医短节]，但通过复盖输入来节省空间 A （和 B），而不是创建副本。
|
注意输入矩阵 |
*例子*
julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
1.0 0.0
0.0 -1.0
julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
0.0 1.0
1.0 0.0
julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im
julia> A
2×2 Matrix{Float64}:
-0.0 -1.0
1.0 -0.0
julia> B
2×2 Matrix{Float64}:
1.0 0.0
0.0 1.0eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values同为 [医短节]，但通过复盖输入来节省空间 A，而不是创建副本。 伊兰奇 是要搜索的特征值_indices_的范围-例如，第2到第8个特征值。
eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values同为 [医短节]，但通过复盖输入来节省空间 A，而不是创建副本。 vl 是搜索特征值的区间的下界，并且 vu 是上界。
# *`线性代数。n.巨量,巨量`*-函数
eigmax(A; permute::Bool=true, scale::Bool=true)返回的最大特征值 A. 选项 排列=真 排列矩阵变得更接近上三角形，并且 比例=真 按其对角线元素缩放矩阵，以使行和列在范数上更加相等。 请注意，如果特征值 A 是复杂的，这种方法将失败，因为复数无法排序。
*例子*
julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
0-1im 0+0im
julia> eigmax(A)
1.0
julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
-1+0im 0+0im
julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]# *`线性代数。[医]特征`*-函数
eigmin(A; permute::Bool=true, scale::Bool=true)返回的最小特征值 A. 选项 排列=真 排列矩阵变得更接近上三角形，并且 比例=真 按其对角线元素缩放矩阵，以使行和列在范数上更加相等。 请注意，如果特征值 A 是复杂的，这种方法将失败，因为复数无法排序。
*例子*
julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
0-1im 0+0im
朱莉娅>eigmin（A）
-1.0
julia>A=[0im;-1 0]
2×2矩阵{Complex{Int64}}:
0+0im0+1im
-1+0im0+0im
朱莉娅>eigmin（A）
错误：DomainError with Complex{Int64}[0+0im0+1im；-1+0im0+0im]:
`A` 不能具有复数特征值。
[医]堆垛机:
[...]# *`线性代数。eigvecs`*-函数
eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix返回矩阵 M 其列是 A. （该 k可以从切片中获得th特征向量 M[:,k].)
如果特征值的可选向量 [医]短节 被指定, eigvecs 返回具体对应的特征向量。
*例子*
julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
1.0 2.0 ⋅
2.0 2.0 3.0
⋅ 3.0 1.0
julia> eigvals(A)
3-element Vector{Float64}:
-2.1400549446402604
1.0000000000000002
5.140054944640259
julia> eigvecs(A)
3×3 Matrix{Float64}:
0.418304 -0.83205 0.364299
-0.656749 -7.39009e-16 0.754109
0.627457 0.5547 0.546448
julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
0.8320502943378438
4.263514128092366e-17
-0.5547001962252291eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix返回矩阵 M 其列是 A. （该 k可以从切片中获得th特征向量 M[:,k].)的 排列,排列, 比例尺，而 索特比 关键字与for相同 本征.
*例子*
julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0eigvecs(A, B) -> Matrix返回矩阵 M 其列是 A 和 B. （该 k可以从切片中获得th特征向量 M[:,k].)
*例子*
julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
1 0
0 -1
julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
0 1
1 0
julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
0.0+1.0im 0.0-1.0im
-1.0+0.0im -1.0-0.0im# *`线性代数。本征`*-函数
eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen计算特征值分解 A，返回 本征因式分解对象 F 其中包含特征值在 F.价值观 和矩阵列中的归一化特征向量 F.向量. 这对应于求解形式的特征值问题 Ax=λx，在哪里 A 是矩阵, x 是特征向量，并且 λ 是特征值。 （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
对于一般的非对称矩阵，可以在特征向量计算之前指定矩阵的平衡方式。 选项 排列=真 排列矩阵变得更接近上三角形，并且 比例=真 按其对角线元素缩放矩阵，以使行和列在范数上更加相等。 默认值为 真的 对于这两个选项。
默认情况下，特征值和向量按字典排序 繝ｼ繝ｫ縺ｧ縺呐. 不同的比较函数 由(λ) 可以传递给 索特比，或者你可以通过 sortby=没什么 以任意顺序离开特征值。 一些特殊的矩阵类型（例如 对角线或 SymTridiagonal缧)可以实施自己的排序约定，而不接受 索特比 关键字。
*例子*
julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
1.0
3.0
18.0
vectors:
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> F.values
3-element Vector{Float64}:
1.0
3.0
18.0
julia> F.vectors
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> vals, vecs = F; # destructuring via iteration
julia> vals == F.values && vecs == F.vectors
trueeigen(A, B; sortby) -> GeneralizedEigen计算广义特征值分解 A 和 B，返回 [医将军]因式分解对象 F 其中包含广义特征值在 F.价值观 和矩阵列中的广义特征向量 F.向量. 这对应于求解形式的广义特征值问题 Ax=λBx，在哪里 A、B 是矩阵, x 是特征向量，并且 λ 是特征值。 （该 k可以从切片中获得th广义特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
默认情况下，特征值和向量按字典排序 繝ｼ繝ｫ縺ｧ縺呐. 不同的比较函数 由(λ) 可以传递给 索特比，或者你可以通过 sortby=没什么 以任意顺序离开特征值。
*例子*
julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
1 0
0 -1
julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
0 1
1 0
julia> F = eigen(A, B);
julia> F.values
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im
julia>f.向量
2×2矩阵{ComplexF64}:
0.0+1.0im0.0-1.0im
-1.0+0.0im-1.0-0.0im
julia>vals,vecs=F;#通过迭代解构
julia>vals==F.values&&vecs==f.vectors
真的eigen(A::Union{Hermitian, Symmetric}; alg::LinearAlgebra.Algorithm = LinearAlgebra.default_eigen_alg(A)) -> Eigen计算特征值分解 A，返回 本征因式分解对象 F 其中包含特征值在 F.价值观 和矩阵列中的正交特征向量 F.向量. （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
阿尔格 指定用于特征值分解的算法和LAPACK方法:
* alg=DivideAndConquer（）：电话 拉帕克。赛夫德！.
* alg=QRIteration（）：电话 拉帕克。赛耶夫！.
* alg=鲁棒代表() （默认）：多个相对健壮的表示方法，调用 拉帕克。syevr！.
参见James W.Demmel等，SIAM J.Sci. 康普特。 30,3,1508(2008)用于比较不同算法的精度和性能。
默认值 阿尔格 使用可能会在未来发生变化。
|
兼容性
朱莉娅1.12 |
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen计算特征值分解 A，返回 本征因式分解对象 F 其中包含特征值在 F.价值观 和矩阵列中的正交特征向量 F.向量. （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
该 单位范围 伊兰奇 指定要搜索的已排序特征值的索引。
|
注意： |
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen计算特征值分解 A，返回 本征因式分解对象 F 其中包含特征值在 F.价值观 和矩阵列中的正交特征向量 F.向量. （该 k可以从切片中获得th特征向量 F.向量[:,k].)
迭代分解生成组件 F.价值观 和 F.向量.
|
注意如果[ |
# *`线性代数。赫森伯格`*-函数
hessenberg(A) -> Hessenberg计算Hessenberg分解 A 并返回一个 赫森伯格 对象。 如果 F 是因式分解对象，酉矩阵可以用 F.Q (类别) 线性代数。海森伯格）和Hessenberg矩阵与 F.H (类别) xref:stdlib/LinearAlgebra.adoc#LinearAlgebra.UpperHessenberg[上海森伯格），其中任何一个都可以转换为具有 矩阵(F.H) 或 矩阵(F.Q).
如果 A 是 赫米蒂安或真实-对称，则赫森伯格分解产生实对称三棱柱矩阵和 F.H 是类型 SymTridiagonal缧.
请注意，移位的因式分解 A+μi=Q(H+μi)Q' 可以通过以下方式高效构建 F+μ*I 使用 制服,制服对象 我，这创造了一个新的 赫森伯格 具有共享存储和修改移位的对象。 给定的转变 F 是由 F.μ. 这很有用，因为多个移位求解 (F+μ*I)\b （对于不同 μ 和/或 b）可以高效地执行一次 F 被创建。
迭代分解会产生以下因子 F.Q,F.H,f.μ.
*例子*
julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
4.0 9.0 7.0
4.0 4.0 1.0
4.0 3.0 2.0
julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
4.0 -11.3137 -1.41421
-5.65685 5.0 2.0
⋅ -8.88178e-16 1.0
julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
4.0 9.0 7.0
4.0 4.0 1.0
4.0 3.0 2.0
julia> q, h = F; # destructuring via iteration
julia> q == F.Q && h == F.H
true# *`线性代数。舒尔`*-类型
Schur <: Factorization矩阵因式分解矩阵的Schur因式分解类型 A. 这是返回类型 舒尔(_)，对应的矩阵因式分解函数。
如果 F::舒尔 是因式分解对象，（准）三角舒尔因子可以通过任 F.舒尔 或 F.T 和正交/酉Schur向量通过 F.向量 或 F.Z 这样， A=f.vectors*F.Schur*F.vectors'. 的特征值 A 可以获得与 F.价值观.
迭代分解生成组件 F.T, F.Z，而 F.价值观.
*例子*
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0
Z factor:
2×2 Matrix{Float64}:
0.961524 0.274721
-0.274721 0.961524
eigenvalues:
2-element Vector{Float64}:
3.0
-2.0
julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia>t,z,vals=F;#通过迭代解构
julia>t==F.T&&z==F.Z&&vals==f.values
真的# *`线性代数。[医]将军`*-类型
GeneralizedSchur <: Factorization两个矩阵的广义舒尔因式分解的矩阵因式分解类型 A 和 B. 这是返回类型 舒尔(,)，对应的矩阵因式分解函数。
如果 F::一般化 是因式分解对象，则（准）三角Schur因子可以通过 F.S. 和 F.T，左酉/正交Schur向量通过 F.左 或 F.Q，而右酉/正交Schur向量可以得到与 F.右 或 F.Z 这样， A=f.左*F.S*f.右' 和 B=f.左*F.T*f.右'. 的广义特征值 A 和 B 可以获得与 F.α．/F.β.
迭代分解生成组件 F.S., F.T, F.Q, F.Z, F.α，而 F.β.
# *`线性代数。舒尔`*-函数
schur(A) -> F::Schur计算矩阵的Schur因子分解 A. （准）三角舒尔因子可以从 舒尔 对象 F 与任 F.舒尔 或 F.T 和正交/酉Schur向量可以得到与 F.向量 或 F.Z 这样， A=f.vectors*F.Schur*F.vectors'. 的特征值 A 可以获得与 F.价值观.
说真的 A，Schur因式分解是"准三角形"，这意味着它是上三角形，除了对于任何共轭对复特征值的2×2对角线块;这允许因式分解是纯实的，即使存在复特征值。 要从真正的准三角形因式分解中获得（复数）纯上三角舒尔因式分解，您可以使用 舒尔{Complex}(schur(A)).
迭代分解生成组件 F.T, F.Z，而 F.价值观.
*例子*
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0
Z factor:
2×2 Matrix{Float64}:
0.961524 0.274721
-0.274721 0.961524
eigenvalues:
2-element Vector{Float64}:
3.0
-2.0
julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> t, z, vals = F; # destructuring via iteration
julia> t == F.T && z == F.Z && vals == F.values
trueschur(A, B) -> F::GeneralizedSchur计算矩阵的广义Schur（或QZ）因子分解 A 和 B. （准）三角舒尔因子可以从 舒尔 对象 F 与 F.S. 和 F.T，左酉/正交Schur向量可以得到与 F.左 或 F.Q 和右酉/正交Schur向量可以得到与 F.右 或 F.Z 这样， A=f.左*F.S*f.右' 和 B=f.左*F.T*f.右'. 的广义特征值 A 和 B 可以获得与 F.α．/F.β.
迭代分解生成组件 F.S., F.T, F.Q, F.Z, F.α，而 F.β.
# *`线性代数。舒尔！`*-函数
schur!(A) -> F::Schur同为 舒尔但使用输入参数 A 作为工作区。
*例子*
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia>F=schur！(一)
舒尔{Float64, Matrix{Float64}，向量{Float64}}
T因子:
2×2矩阵{Float64}:
3.0 9.0
0.0 -2.0
Z因子:
2×2矩阵{Float64}:
0.961524 0.274721
-0.274721 0.961524
特征值:
2元素向量{Float64}:
3.0
-2.0
朱莉娅>A
2×2矩阵{Float64}:
3.0 9.0
0.0 -2.0schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur同为 舒尔但使用输入矩阵 A 和 B 作为工作区。
# *`线性代数。奥德舒尔`*-函数
ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur重新排序Schur因子分解 F 矩阵的 A=Z*T*Z' 根据逻辑数组 选择 返回重新排序的因式分解 F 对象。 选定的特征值出现在 F.舒尔 和相应的前导列 F.向量 形成相应右不变子空间的正交/酉基。 在真实情况下，特征值的复共轭对必须既包括在内，也必须通过 选择.
ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur重新排序广义Schur因子分解 F 矩阵对 (A,B)=(Q*S*Z',Q*T*Z') 根据逻辑数组 选择 并返回一个GeneralizedSchur对象 F. 所选特征值出现在两者的前导对角线中 F.S. 和 F.T，并且左和右正交/酉Schur向量也被重新排序使得 (A,B)=F.Q*(F.S,F.T)*F.Z' 仍然成立和广义特征值 A 和 B 仍然可以获得与 F.α．/F.β.
# *`线性代数。SVD`*-类型
SVD <: Factorization矩阵的奇异值分解（SVD）的矩阵因式分解类型 A. 这是返回类型 svd(_)，对应的矩阵因式分解函数。
如果 F::SVD 是因式分解对象, U, S, V 和 Vt;Vt 可通过 F.U, F.S., F.V 和 F.Vt，这样 A=U*对角线(S)*Vt. 奇异值 S 按降序排序。
迭代分解生成组件 U, S，而 V.
*例子*
julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
1.0 0.0 0.0 0.0 2.0
0.0 0.0 3.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 2.0 0.0 0.0 0.0
julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
0.0 1.0 0.0 0.0
1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0
0.0 0.0 -1.0 0.0
singular values:
4-element Vector{Float64}:
3.0
2.23606797749979
2.0
0.0
Vt factor:
4×5 Matrix{Float64}:
-0.0 0.0 1.0 -0.0 0.0
0.447214 0.0 0.0 0.0 0.894427
0.0 -1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0 0.0
julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
1.0 0.0 0.0 0.0 2.0
0.0 0.0 3.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 2.0 0.0 0.0 0.0
julia> u, s, v = F; # destructuring via iteration
julia> u == F.U && s == F.S && v == F.V
true# *`线性代数。[医]总`*-类型
GeneralizedSVD <: Factorization两个矩阵的广义奇异值分解（SVD）的矩阵因式分解类型 A 和 B，这样 A=F.U*F.D1*F.R0*F.Q' 和 B=F.V*F.D2*F.R0*F.Q'. 这是返回类型 svd(,)，对应的矩阵因式分解函数。
对于一个M乘N矩阵 A 和P-by-N矩阵 B,
* U 是一个m-by-M正交矩阵,
* V 是P-by-p正交矩阵,
* Q 是n乘n正交矩阵,
* D1 是前K个条目中有1s的m-by-(K+L)对角矩阵,
* D2 是一个p-by-(K+L)矩阵，其右上l-by-l块是对角线,
* R0 是一个(K+L)-by-N矩阵，其最右边的(K+L)-by-(K+L)块是非星形上块三角形,
K+L 是矩阵的有效数值秩 [A;B].
迭代分解生成组件 U, V, Q, D1, D2，而 R0.
的条目 F.D1 和 F.D2 是相关的，如LAPACK文档中所述https://www.netlib.org/lapack/lug/node36.html[广义SVD]和https://www.netlib.org/lapack/explore-html/d6/db3/dggsvd3_8f.html[xGGSVD3]下面调用的例程（在LAPACK3.6.0和更新版本中）。
*例子*
julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
1.0 0.0
0.0 -1.0
julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
0.0 1.0
1.0 0.0
julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
1.0 0.0
0.0 1.0
V factor:
2×2 Matrix{Float64}:
-0.0 -1.0
1.0 0.0
Q factor:
2×2 Matrix{Float64}:
1.0 0.0
0.0 1.0
D1 factor:
2×2 Matrix{Float64}:
0.707107 0.0
0.0 0.707107
D2 factor:
2×2 Matrix{Float64}:
0.707107 0.0
0.0 0.707107
R0 factor:
2×2 Matrix{Float64}:
1.41421 0.0
0.0 -1.41421
julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
1.0 0.0
0.0 -1.0
julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
-0.0 1.0
1.0 0.0# *`线性代数。svd`*-函数
svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD计算奇异值分解（SVD） A 并返回一个 SVD 对象。
U, S, V 和 Vt;Vt 可以从因式分解中获得 F 与 F.U, F.S., F.V 和 F.Vt，这样 A=U*对角线(S)*Vt. 该算法产生 Vt;Vt 因此 Vt;Vt 提取效率比提取效率高 V. 奇异值 S 按降序排序。
迭代分解生成组件 U, S，而 V.
如果 全=错误 （默认），返回"瘦"SVD。 对于一个 矩阵 A，在全因式分解 U 是 和 V 是 ，而在薄因式分解 U 是 和 V 是 ，在哪里 是奇异值的数目。
阿尔格 指定用于SVD的算法和LAPACK方法:
* alg=LinearAlgebra。DivideAndConquer（） （默认）：调用 拉帕克。gesdd！.
* alg=LinearAlgebra。QRIteration()：电话 拉帕克。gesvd！ （通常较慢但更准确）。
|
兼容性
朱莉娅1.3 |
*例子*
julia> A = rand(4,3);
julia> F = svd(A); # Store the Factorization Object
julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true
julia> U, S, V = F; # destructuring via iteration
julia> A ≈ U * Diagonal(S) * V'
true
julia>Uonly,=svd(A);#Store u only
朱莉娅>Uonly==U
真的svd(A, B) -> GeneralizedSVD计算广义SVD A 和 B，返回 [医]总 因式分解对象 F 这样， [A;B]=[F.U*F.D1;F.V*F.D2]*F.R0*F.Q'
* U 是m-by-M正交矩阵,
* V 是P-by-p正交矩阵,
* Q 是n乘n正交矩阵,
* D1 是前K个条目中有1s的m-by-(K+L)对角矩阵,
* D2 是一个p-by-(K+L)矩阵，其右上l-by-l块是对角线,
* R0 是一个(K+L)-by-N矩阵，其最右边的(K+L)-by-(K+L)块是非星形上块三角形,
K+L 是矩阵的有效数值秩 [A;B].
迭代分解生成组件 U, V, Q, D1, D2，而 R0.
广义SVD用于应用程序，例如当人们想要比较多少属于 A vs.多少属于 B，如在人类vs酵母基因组，或信号vs噪声，或簇之间vs簇内。 （参见Edelman和Wang讨论：https://arxiv.org/abs/1901.00485）
它分解 [A;B] 进入 [UC;VS]H，在哪里 [UC;VS] 是列空间的自然正交基 [A;B]，而 H=RQ' 是行空间的自然非正交基 [A;B]，其中顶行最接近归因于 A 矩阵，以及底部到 B 矩阵。 多余弦/正弦矩阵 C 和 S 提供多少的多度量 A vs多少 B，而 U 和 V 提供测量这些的方向。
*例子*
julia> A = randn(3,2); B=randn(4,2);
julia> F = svd(A, B);
julia> U,V,Q,C,S,R = F;
julia> H = R*Q';
julia> [A; B] ≈ [U*C; V*S]*H
true
julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true
julia>Uonly，=svd（A，B）;
朱莉娅>U==Uonly
真的# *`线性代数。svdvals`*-函数
svdvals(A)返回奇异值 A 按降序排列。
*例子*
julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
1.0 0.0 0.0 0.0 2.0
0.0 0.0 3.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 2.0 0.0 0.0 0.0
朱莉娅>svdvals(一)
4元素向量{Float64}:
3.0
2.23606797749979
2.0
0.0svdvals(A, B)从广义奇异值分解返回广义奇异值 A 和 B. 请参阅 svd.
*例子*
julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
1.0 0.0
0.0 -1.0
julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
0.0 1.0
1.0 0.0
julia> svdvals(A, B)
2-element Vector{Float64}:
1.0
1.0# *`线性代数。吉文斯`*-函数
givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)计算Givens旋转 G 和标量 r 使得对于任何向量 x 哪里
x[i1] = f
x[i2] = g乘法的结果
y = G*x拥有
y[i1] = r
y[i2] = 0请参阅 线性代数。吉文斯.
givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)计算Givens旋转 G 和标量 r 这样乘法的结果
B = G*A拥有
B[i1,j] = r
B[i2,j] = 0请参阅 线性代数。吉文斯.
givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)计算Givens旋转 G 和标量 r 这样乘法的结果
B = G*x拥有
B[i1] = r
B[i2] = 0请参阅 线性代数。吉文斯.
# *`线性代数。特里乌`*-函数
triu(M, k::Integer = 0)返回的上部三角形 M 从 kth superdiagonal。
*例子*
julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
julia> triu(a,3)
4×4 Matrix{Float64}:
0.0 0.0 0.0 1.0
0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0
julia> triu(a,-3)
4×4 Matrix{Float64}:
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0# *`线性代数。特里乌！`*-函数
triu!(M)矩阵的上三角形，复盖 M 的过程中。 请参阅 特里乌.
triu!(M, k::Integer)返回的上部三角形 M 从 kth superdiagonal,复盖 M 的过程中。
*例子*
julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
julia> triu!(M, 1)
5×5 Matrix{Int64}:
0 2 3 4 5
0 0 3 4 5
0 0 0 4 5
0 0 0 0 5
0 0 0 0 0# *`线性代数。特里尔`*-函数
tril(M, k::Integer = 0)返回的下三角形 M 从 kth superdiagonal。
*例子*
julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
julia> tril(a,3)
4×4 Matrix{Float64}:
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
julia> tril(a,-3)
4×4 Matrix{Float64}:
0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0
1.0 0.0 0.0 0.0# *`线性代数。特里尔！`*-函数
tril!(M)矩阵的下三角形，复盖 M 的过程中。 请参阅 特里尔.
tril!(M, k::Integer)返回的下三角形 M 从 kth superdiagonal,复盖 M 的过程中。
*例子*
julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
朱莉娅>特里尔！(M,2)
5×5矩阵{Int64}:
1 2 3 0 0
1 2 3 4 0
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5# *`线性代数。[医]成岩`*-函数
diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())一个 抽象范围 给出 k矩阵的th对角线 M. 或者，可以指定一个索引样式来确定返回的范围的类型。 如果 indstyle isa IndexLinear （默认），这返回一个 抽象范围{Integer}. 另一方面，如果 indstyle是IndexCartesian，这返回一个 抽象范围{CartesianIndex{2}}.
如果 k 未提供，假定为 0 （对应于主对角线）。
*例子*
julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
1 2 3
4 5 6
7 8 9
julia> diagind(A, -1)
2:4:6
julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)|
兼容性
Julia1.11指定一个 |
# *`线性代数。图表,图表`*-函数
diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)从构造矩阵 对对角线和矢量的s。 向量资料 千伏。第二 将被放置在 千伏。第一个 对角线。 默认情况下，矩阵是正方形，其大小是从 千伏,千伏，但非正方形大小 m×n （根据需要用零填充）可以通过传递指定 m，n 作为第一个论点。 对于重复的对角线索引 千伏。第一个 相应向量中的值 千伏。第二 将被添加。
图表,图表 构造一个完整的矩阵;如果您想要具有快速算术的存储效率版本，请参阅 对角线, [医双角] 三棱角,三棱角和 SymTridiagonal缧.
*例子*
julia> diagm(1 => [1,2,3])
4×4 Matrix{Int64}:
0 1 0 0
0 0 2 0
0 0 0 3
0 0 0 0
julia> diagm(1 => [1,2,3], -1 => [4,5])
4×4 Matrix{Int64}:
0 1 0 0
4 0 2 0
0 5 0 3
0 0 0 0
julia> diagm(1 => [1,2,3], 1 => [1,2,3])
4×4 Matrix{Int64}:
0 2 0 0
0 0 4 0
0 0 0 6
0 0 0 0diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)构造以向量的元素作为对角元素的矩阵。 默认情况下，矩阵为正方形，其大小由 长度(v)，但非正方形大小 m×n 可以通过传递指定 m，n 作为第一个论点。 如有必要，对角线将为零填充。
*例子*
julia> diagm([1,2,3])
3×3 Matrix{Int64}:
1 0 0
0 2 0
0 0 3
julia> diagm(4, 5, [1,2,3])
4×5 Matrix{Int64}:
1 0 0 0 0
0 2 0 0 0
0 0 3 0 0
0 0 0 0 0# *`线性代数。职级`*-函数
rank(::QRSparse{Tv,Ti}) -> Ti返回QR因子分解的秩
rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti计算 S 通过计算其QR因子分解。 小于的值 托尔 被视为零。 请参阅SPQR的手册。
rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)通过计算矩阵的输出数来计算矩阵的数值秩。 svdvals(一) 大于 max(atol,rtol*σί) 哪里 σ₁ 是 A最大的计算奇异值。 atol公司 和 rtol 分别是绝对和相对公差。 默认的相对容差为 n*ϵ，在哪里 n 是最小尺寸的尺寸 A，而 ϵ 是 每股收益的元素类型 A.
|
注意数值秩可以是具有接近阈值容差的奇异值的病态矩阵的敏感和不精确的表征 |
|
兼容性
朱莉娅1.1 |
*例子*
julia> rank(Matrix(I, 3, 3))
3
julia> rank(diagm(0 => [1, 0, 2]))
2
julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2
julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3
julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1rank(S::SVD{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}计算SVD对象的数值秩 S 通过计算有多少奇异值大于 max(atol,rtol*σί) 哪里 σ₁ 是最大的计算奇异值。 这相当于默认值 等级(::AbstractMatrix)方法，除了它重新使用现有的SVD因子分解。 atol公司 和 rtol 分别是绝对和相对公差。 默认的相对容差为 n*ϵ，在哪里 n 是UΣV’的最小维数的大小和 ϵ 是 每股收益的元素类型 S.
|
兼容性
朱莉娅1.12 |
rank(A::QRPivoted{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}计算QR因子分解的数值秩 A 通过计算有多少对角线条目 A.因素 大于 最大值(atol,rtol*Δ) 哪里 Δ₁ 是最大的计算这样的条目。 这类似于 等级(::AbstractMatrix)方法，因为它计算矩阵因子分解的（数字）非零系数的数量，尽管默认方法使用SVD而不是QR因子分解。 像 等级(::SVD)，该方法还重新使用了现有的矩阵因式分解。
使用QR因子分解来计算秩通常应该产生与使用SVD相同的结果，尽管在矩阵条件不佳的病理情况下，它可能更容易高估秩。 另外值得注意的是，计算QR因子分解通常比计算SVD更快，因此当关注性能时，这种方法可能是首选。
atol公司 和 rtol 分别是绝对和相对公差。 默认的相对容差为 n*ϵ，在哪里 n 是最小尺寸的尺寸 A 和 ϵ 是 每股收益的元素类型 A.
|
兼容性
朱莉娅1.12 |
# *`线性代数。规范`*-函数
norm(A, p::Real=2)对于任何可迭代容器 A （包括任何维度的数组）的数字（或其任何元素类型 规范 被定义），计算 p-norm（默认为 p=2）好像 A 是相应长度的矢量。
该 p-规范定义为
与 的条目 , $ |
a_i |
$的 |
p 可以假设任何数值（即使不是所有值都产生数学上有效的向量范数）。 特别是, 规范(A,Inf) 返回最大值 腹肌。(一)，而 规范(A,-Inf) 返回最小的。 如果 A 是矩阵和 p=2，那么这相当于Frobenius规范。
第二个论点 p 不一定是接口的一部分 规范，即自定义类型可能只实现 规范(A) 没有第二个论点。
使用方法 奥普诺姆计算矩阵的算子范数。
*例子*
julia> v = [3, -2, 6]
3-element Vector{Int64}:
3
-2
6
julia> norm(v)
7.0
julia> norm(v, 1)
11.0
julia> norm(v, Inf)
6.0
julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134
julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134
朱莉娅>规范(1:9)
16.881943016134134
julia>norm(hcat(v,v),1)==norm(vcat(v,v),1)!=范数([v,v],1)
真的
julia>norm(hcat(v,v),2)==norm(vcat(v,v),2)==norm([v,v],2)
真的
julia>norm(hcat(v,v),Inf)==norm(vcat(v,v),Inf)!=范数([v,v],Inf)
真的norm(x::Number, p::Real=2)对于数字，返回$\left( |
x |
p\右）{1/p}$. |
*例子*
julia> norm(2, 1)
2.0
julia> norm(-2, 1)
2.0
julia> norm(2, 2)
2.0
julia> norm(-2, 2)
2.0
julia> norm(2, Inf)
2.0
julia> norm(-2, Inf)
2.0# *`线性代数。奥普诺姆`*-函数
opnorm(A::AbstractMatrix, p::Real=2)计算由向量引起的算子范数（或矩阵范数） p-范数，其中有效值为 p 是 1, 2，或 资讯. （注意，对于稀疏矩阵, p=2 目前尚未实施。)使用 规范计算Frobenius范数。
何时 p=1，运算符范数是最大绝对列和 A:
与 的条目 ，而 和 它的尺寸。
何时 p=2，算子范数为谱范数，等于最大奇异值为 A.
何时 p=Inf，运算符范数是最大绝对行和 A:
*例子*
julia> A = [1 -2 -3; 2 3 -1]
2×3 Matrix{Int64}:
1 -2 -3
2 3 -1
julia> opnorm(A, Inf)
6.0
julia> opnorm(A, 1)
5.0opnorm(x::Number, p::Real=2)对于数字，返回$\left( |
x |
p\右）{1/p}$. 这相当于 |
opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)对于Adjoint/Transpose-wrapped向量，返回运算符 -规范 A，相当于 p-规范与价值 p=q/(q-1). 它们在 p=q=2. 使用方法 规范计算 p 规范的 A 作为载体。
向量空间与其对偶之间的范数差异是为了保持对偶和点积之间的关系，结果与算子一致 p-a的规范 1×n 矩阵。
*例子*
julia> v = [1; im];
julia> vc = v';
julia> opnorm(vc, 1)
1.0
julia> norm(vc, 1)
2.0
julia> norm(v, 1)
2.0
julia> opnorm(vc, 2)
1.4142135623730951
julia> norm(vc, 2)
1.4142135623730951
julia> norm(v, 2)
1.4142135623730951
julia> opnorm(vc, Inf)
2.0
julia> norm(vc, Inf)
1.0
julia> norm(v, Inf)
1.0# *`线性代数。正常化`*-函数
normalize(a, p::Real=2)*例子*
julia> a = [1,2,4];
julia> b = normalize(a)
3-element Vector{Float64}:
0.2182178902359924
0.4364357804719848
0.8728715609439696
julia> norm(b)
1.0
julia> c = normalize(a, 1)
3-element Vector{Float64}:
0.14285714285714285
0.2857142857142857
0.5714285714285714
julia> norm(c, 1)
1.0
julia> a = [1 2 4 ; 1 2 4]
2×3 Matrix{Int64}:
1 2 4
1 2 4
julia> norm(a)
6.48074069840786
julia> normalize(a)
2×3 Matrix{Float64}:
0.154303 0.308607 0.617213
0.154303 0.308607 0.617213
朱莉娅>正常化(3,1)
1.0
朱莉娅>正常化(-8,1)
-1.0
朱莉娅>正常化(0,1)
南# *`线性代数。康斯基尔`*-函数
condskeel(M, [x, p::Real=Inf])Skeel条件编号 矩阵的 M，可选地相对于载体 x，使用运算符计算 p-诺姆。 表示（条目明智）的绝对值的矩阵 ; . 有效值 p 是 1, 2 和 资讯 （默认）。
该量在文献中也被称为相对条件数、相对条件数或组分相对条件数。
# *`LinearAlgebra.tr`*-函数
tr(M)矩阵跟踪。 求和的对角线元素 M.
*例子*
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> tr(A)
5# *`线性代数。德特`*-函数
det(M)矩阵行列式。
请参阅: logdet,logdet和 n.logabsdet.
*例子*
julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
1 0
2 2
julia> det(M)
2.0请注意，一般来说, 德特 计算行列式的浮点近似，即使是整数矩阵，通常通过高斯消除。 Julia包含整数行列式的确切算法（Bareiss算法），但默认情况下仅将其用于 比金特 矩阵（因为行列式快速溢出任何固定整数精度）:
julia> det(BigInt[1 0; 2 2]) # exact integer determinant
2# *`线性代数。logdet,logdet`*-函数
logdet(M)矩阵行列式的对数。 相当于 日志(det(M))，但可提供增加的精度并避免上溢/下溢。
*例子*
julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
1 0
2 2
julia> logdet(M)
0.6931471805599453
julia> logdet(Matrix(I, 3, 3))
0.0# *`线性代数。n.logabsdet`*-函数
logabsdet(M)矩阵行列式绝对值的Log。 相当于 (log(abs(det(M))),sign(det(M)))，但可提供增加的精度和/或速度。
*例子*
julia> A = [-1. 0.; 0. 1.]
2×2 Matrix{Float64}:
-1.0 0.0
0.0 1.0
julia> det(A)
-1.0
julia> logabsdet(A)
(0.0, -1.0)
julia> B = [2. 0.; 0. 1.]
2×2 Matrix{Float64}:
2.0 0.0
0.0 1.0
julia> det(B)
2.0
julia> logabsdet(B)
(0.6931471805599453, 1.0)# *`基地。因维`*-Method
inv(M)矩阵求逆。 计算矩阵 N 这样， M*N=I，在哪里 我 是单位矩阵。 通过求解左除法计算 N=M\I.
A SingularException被抛出，如果 M 数值反演失败。
*例子*
julia> M = [2 5; 1 3]
2×2 Matrix{Int64}:
2 5
1 3
julia> N = inv(M)
2×2 Matrix{Float64}:
3.0 -5.0
-1.0 2.0
julia>M*N==N*M==矩阵(I,2,2)
真的# *`线性代数。pinv`*-函数
pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0计算摩尔-彭罗斯伪宇宙。
对于矩阵 M 对于浮点元素，通过仅反转大于的奇异值来计算伪逆是很方便的 max(atol,rtol*σί) 哪里 σ₁ 是最大的奇异值 M.
绝对的最佳选择（atol公司）和相对公差（rtol)随 M 和伪逆的预期应用。 默认的相对容差为 n*ϵ，在哪里 n 是最小尺寸的尺寸 M，而 ϵ 是 每股收益的元素类型 M.
用于在最小二乘意义上反转密集条件矩阵, rtol=sqrt（eps（real（float（oneunit（eltype（M））））））） 被推荐。
有关更多信息，请参阅脚注：issue8859[Issue8859,"Fix least squares",https://github.com/JuliaLang/julia/pull/8859],脚注:B96[Åke Björck,"Numerical Methods for Least Squares Problems",SIAM Press,Philadelphia,1996,"Other Titles in Applied Mathematics",Vol. 51. doi：10.1137/1.9781611971484]，脚注：S84[G.W.Stewart，"Rank Degeneracy"，SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. doi：10.1137/0905030]，脚注：KY88[Konstantinos Konstantinides和Kung Yao，"matrix rank determination中有效奇异值的统计分析"，IEEE Transactions on Acoustics，Speech and Signal Processing, 36(5), 1988, 757-763. doi：10.1109/29.1585]。
*例子*
julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
1.5 1.3
1.2 1.9
julia> N = pinv(M)
2×2 Matrix{Float64}:
1.47287 -1.00775
-0.930233 1.16279
julia> M * N
2×2 Matrix{Float64}:
1.0 -2.22045e-16
4.44089e-16 1.0# *`线性代数。空空间`*-函数
nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0计算为空空间的基础 M 通过包括的奇异向量 M 其奇异值的大小小于 max(atol,rtol*σί)，在哪里 σ₁ 是 M的最大奇异值。
默认情况下，相对容差 rtol 是 n*ϵ，在哪里 n 是最小尺寸的尺寸 M，而 ϵ 是 每股收益的元素类型 M.
*例子*
julia> M = [1 0 0; 0 1 0; 0 0 0]
3×3 Matrix{Int64}:
1 0 0
0 1 0
0 0 0
julia> nullspace(M)
3×1 Matrix{Float64}:
0.0
0.0
1.0
julia> nullspace(M, rtol=3)
3×3 Matrix{Float64}:
0.0 1.0 0.0
1.0 0.0 0.0
0.0 0.0 1.0
julia> nullspace(M, atol=0.95)
3×1 Matrix{Float64}:
0.0
0.0
1.0# *`基地。克伦`*-函数
kron(A, B)计算两个向量，矩阵或数字的Kronecker乘积。
对于真实向量 v 和 w，Kronecker产品与外部产品相关 kron(v,w)==vec(w*转置(v)) 或 w*transpose(v)==reshape(kron(v,w),(length(w),length(v))). 注意如何订购 v 和 w 这些表达式的左侧和右侧不同（由于列主存储）。 对于复数向量，外积 w*v' 也不同于 v.
*例子*
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> B = [im 1; 1 -im]
2×2 Matrix{Complex{Int64}}:
0+1im 1+0im
1+0im 0-1im
julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
0+1im 1+0im 0+2im 2+0im
1+0im 0-1im 2+0im 0-2im
0+3im 3+0im 0+4im 4+0im
3+0im 0-3im 4+0im 0-4im
julia> v = [1, 2]; w = [3, 4, 5];
julia> w*transpose(v)
3×2 Matrix{Int64}:
3 6
4 8
5 10
julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
3 6
4 8
5 10exp(A::AbstractMatrix)计算矩阵指数 A，定义为
对于对称或隐密 A，一个eigendecomposition(本征)被使用，否则缩放和平方算法（参见脚注：H05[Nicholas J.Higham，"the squaring and scaling method for the matrix exponential revisited"，SIAM Journal on Matrix Analysis and Applications, 26(4), 2005, 1179-1193. doi:10.1137/090768539])被选择。
*例子*
julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
1.0 0.0
0.0 1.0
julia> exp(A)
2×2 Matrix{Float64}:
2.71828 0.0
0.0 2.71828# *`基地。:^`*-Method
^(A::AbstractMatrix, p::Number)矩阵功率，相当于
*例子*
julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
1 26
0 27# *`基地。:^`*-Method
^(b::Number, A::AbstractMatrix)矩阵指数，相当于 .
|
兼容性
Julia1.1支持抚养 |
*例子*
julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
2.0 6.0
0.0 8.0
julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
2.71828 17.3673
0.0 20.0855# *`基地。日志`*-Method
log(A::AbstractMatrix)如果 A 没有负实特征值，计算主矩阵对数 A，即唯一矩阵 这样， 和 对于所有的特征值 的 . 如果 A 具有非正态分布的特征值,只要可能,就返回一个非正态分布的矩阵函数.
如果 A 是对称的或隐密的，它的eigendecomposition(本征)被使用，如果 A 是采用逆缩放和平方法的改进版本（参见脚注：AH12[Awad H.Al-Mohy和Nicholas J.Higham，"Improved inverse scaling and squaring algorithms for the matrix logarithm"，SIAM Journal on Scientific Computing，34(4)，2012，C153-C169. doi：10.1137/110852553]和脚注：AHR13[Awad H.Al-Mohy，Nicholas J.Higham和Samuel D.Relton，"计算矩阵对数的Fréchet导数并估计条件数"，SIAM Journal On Scientific Computing，35（4），2013，C394-C410。 doi：10.1137/120885991]）。 A 是实的，没有负特征值，则计算实数形式。 否则，计算复数Schur形式。 然后在上（准）三角因子上使用脚注：AHR13[]中的上（准）三角算法。
*例子*
julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
2.71828 0.0
0.0 2.71828
julia> log(A)
2×2 Matrix{Float64}:
1.0 0.0
0.0 1.0# *`基地。sqrt,sqrt`*-Method
sqrt(x)回来吧 .
前缀运算符 √ 相当于 sqrt,sqrt.
|
分支切割 |
请参阅: [医hypot].
*例子*
julia> sqrt(big(81))
9.0
julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
[1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]
julia> sqrt(big(complex(-81)))
0.0 + 9.0im
julia> sqrt(-81 - 0.0im) # -0.0im is below the branch cut
0.0 - 9.0im
julia> .√(1:4)
4-element Vector{Float64}:
1.0
1.4142135623730951
1.7320508075688772
2.0sqrt(A::AbstractMatrix)如果 A 没有负实特征值，计算主矩阵平方根 A，即唯一矩阵 具有正实部的特征值使得 . 否则，将返回一个非索引平方根。
如果 A 是实对称或Hermitian，它的eigendecomposition（本征)用于计算平方根。 对于这样的矩阵，由于舍入误差而看起来稍微为负的特征值λ被视为零。 更确切地说，具有所有特征值的矩阵 ≥-rtol*(最大/λ|) 被视为半辉石（产生Hermitian平方根），负特征值为零。 rtol 是关键字参数 sqrt,sqrt （仅在Hermitian/real-symmetric情况下），默认为按以下比例缩放的机器精度 尺寸(A,1).
否则，通过Björck-Hammarling方法脚注确定平方根：BH83[Åke Björck和Sven Hammarling，"a Schur method for the square root of a matrix"，Linear Algebra and its Applications，52-53，1983，127-140。 doi:10.1016/0024-3795(83)80010-X]，其计算复数形式（舒尔)然后是三角因子的复平方根。 如果存在实平方根，那么该方法的扩展脚注：H87[Nicholas J.Higham，"Computing real square roots of a real matrix"，Linear Algebra and its Applications，88-89，1987，405-430. doi:10.1016/0024-3795(87)90118-2] 即计算真实的Schur形式，然后使用准三角形因子的真实平方根。
*例子*
julia> A = [4 0; 0 4]
2×2 Matrix{Int64}:
4 0
0 4
julia> sqrt(A)
2×2 Matrix{Float64}:
2.0 0.0
0.0 2.0# *`基地。数学。银监会`*-Method
cbrt(A::AbstractMatrix{<:Real})计算实值矩阵的实值立方根 A. 如果 T=cbrt（A），那么我们有 T*T*T≈A，见下面给出的例子。
如果 A 对称，即类型 隐士,隐士{<:Real}，则（本征)用于查找多维数据集根。 否则，专门版本的第p根算法脚注：S03[Matthew I.Smith，"A Schur Algorithm For Computing Matrix pth Roots"，SIAM Journal on Matrix Analysis and Applications，vol. 24，2003，第971-989页。 doi:10.1137/S0895479801392697]被利用，其利用实值Schur分解（舒尔)来计算多维数据集根。
*例子*
julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
0.927524 -0.15857
-1.3677 -1.01172
julia> T = cbrt(A)
2×2 Matrix{Float64}:
0.910077 -0.151019
-1.30257 -0.936818
julia> T*T*T ≈ A
trues15"} where var"#s15"<:Real}"> *`基地。[医]`*-Method
cos(A::AbstractMatrix)计算方阵的矩阵余弦 A.
*例子*
julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
0.291927 -0.708073
-0.708073 0.291927s15"} where var"#s15"<:Real}"> *`基地。罪`*-Method
sin(A::AbstractMatrix)计算方阵的矩阵正弦 A.
*例子*
julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
0.454649 0.454649
0.454649 0.454649s15"} where var"#s15"<:Real}"> *`基地。数学。辛科斯`*-Method
sincos(A::AbstractMatrix)计算方阵的矩阵正弦和余弦 A.
*例子*
julia> S, C = sincos(fill(1.0, (2,2)));
julia> S
2×2 Matrix{Float64}:
0.454649 0.454649
0.454649 0.454649
朱莉娅>C
2×2矩阵{Float64}:
0.291927 -0.708073
-0.708073 0.291927s15"} where var"#s15"<:Real}"> *`基地。谭ｱ莠ｬ`*-Method
tan(A::AbstractMatrix)计算方阵的矩阵正切 A.
*例子*
julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
-1.09252 -1.09252
-1.09252 -1.09252# *`基地。助理文书主任`*-Method
acos(A::AbstractMatrix)计算方阵的逆矩阵余弦 A.
如果 A 是对称的或隐密的，它的eigendecomposition(本征)用于计算反余弦。 否则，反余弦通过使用确定 日志和 sqrt,sqrt. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_1[Mary Aprahamian和Nicholas J.Higham，"矩阵逆三角函数和逆双曲函数：理论和算法"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
*例子*
julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
0.5-8.32667e-17im 0.1+0.0im
-0.2+2.63678e-16im 0.3-3.46945e-16im# *`基地。阿辛`*-Method
asin(A::AbstractMatrix)计算方阵的逆矩阵正弦 A.
如果 A 是对称的或隐密的，它的eigendecomposition(本征)用于计算逆正弦。 否则，反正弦通过使用确定 日志和 sqrt,sqrt. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_2[Mary Aprahamian和Nicholas J.Higham，"矩阵逆三角函数和逆双曲函数：理论和算法"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
*例子*
julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
0.5-4.16334e-17im 0.1-5.55112e-17im
-0.2+9.71445e-17im 0.3-1.249e-16im# *`基地。阿坦`*-Method
atan(A::AbstractMatrix)计算方阵的逆矩阵正切 A.
如果 A 是对称的或隐密的，它的eigendecomposition(本征)用于计算反切。 否则，反切通过使用确定 日志. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_3[Mary Aprahamian和Nicholas J.Higham，"矩阵逆三角函数和逆双曲函数：理论和算法"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
*例子*
julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
0.5+1.38778e-17im 0.1-2.77556e-17im
-0.2+6.93889e-17im 0.3-4.16334e-17im# *`基地。阿科什`*-Method
acosh(A::AbstractMatrix)计算方阵的逆双曲矩阵余弦 A. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_4[Mary Aprahamian和Nicholas J.Higham，"Matrix Inverse Trigonometric and Inverse Hyperbolic Functions：Theory and Algorithms"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
# *`基地。阿辛`*-Method
asinh(A::AbstractMatrix)计算方阵的逆双曲矩阵正弦 A. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_5[Mary Aprahamian和Nicholas J.Higham，"矩阵逆三角函数和逆双曲函数：理论和算法"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
# *`基地。阿坦`*-Method
atanh(A::AbstractMatrix)计算方阵的逆双曲矩阵正切 A. 对于用于计算该函数的理论和对数公式，参见脚注：AH16_6[Mary Aprahamian和Nicholas J.Higham，"矩阵逆三角函数和逆双曲函数：理论和算法"，MIMS EPrint：2016.4。 https://doi.org/10.1137/16M1057577]。
# *`线性代数。利亚普`*-函数
lyap(A, C)计算解决方案 X 到连续Lyapunov方程 AX+XA'+C=0，其中没有特征值的 A 具有零实部并且没有两个特征值是彼此的负复共轭。
*例子*
julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
3.0 4.0
5.0 6.0
julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
1.0 1.0
1.0 2.0
julia> X = lyap(A, B)
2×2 Matrix{Float64}:
0.5 -0.5
-0.5 0.25
julia> A*X + X*A' ≈ -B
true# *`线性代数。西尔维斯特`*-函数
sylvester(A, B, C)计算解决方案 X 到西尔维斯特方程 AX+XB+C=0，在哪里 A, B 和 C 具有兼容的尺寸和 A 和 -B 没有实部相等的特征值。
*例子*
julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
3.0 4.0
5.0 6.0
julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
1.0 1.0
1.0 2.0
julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
1.0 2.0
-2.0 1.0
julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
-4.46667 1.93333
3.73333 -1.8
julia> A*X + X*B ≈ -C
true# *`线性代数。伊斯成功`*-函数
issuccess(F::Factorization)测试矩阵的因式分解是否成功。
|
兼容性
朱莉娅1.6 |
*例子*
julia> F = cholesky([1 0; 0 1]);
julia> issuccess(F)
trueissuccess(F::LU; allowsingular = false)测试矩阵的LU因子分解成功。 默认情况下，生成有效但秩缺陷U因子的因式分解被视为失败。 这可以通过传递来改变 allowsingular=true.
|
兼容性
朱莉娅1.11 |
*例子*
julia> F = lu([1 2; 1 2], check = false);
julia> issuccess(F)
false
julia> issuccess(F, allowsingular = true)
true# *`线性代数。issymmetric碌录潞陆`*-函数
issymmetric(A) -> Bool测试矩阵是否对称。
*例子*
julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
1 2
2 -1
julia> issymmetric(a)
true
julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
1+0im 0+1im
0-1im 1+0im
julia> issymmetric(b)
false# *`线性代数。伊斯特里尔`*-函数
istril(A::AbstractMatrix, k::Integer = 0) -> Bool测试是否 A 是从 kth superdiagonal。
*例子*
julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
1 2
2 -1
julia> istril(a)
false
julia> istril(a, 1)
true
julia> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
1 1 0
1 1 1
1 1 1
julia> istril(c)
false
julia> istril(c, 1)
true# *`线性代数。伊斯特里乌`*-函数
istriu(A::AbstractMatrix, k::Integer = 0) -> Bool测试是否 A 上三角形从 kth superdiagonal。
*例子*
julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
1 2
2 -1
julia> istriu(a)
false
朱莉娅>istriu（a，-1）
真的
朱莉娅>c= [1 1 1; 1 1 1; 0 1 1]
3×3矩阵{Int64}:
1 1 1
1 1 1
0 1 1
朱莉娅>istriu（c）
错误
朱莉娅>istriu（c，-1）
真的# *`线性代数。伊斯迪亚格`*-函数
isdiag(A) -> Bool测试一个矩阵是否是对角的 iszero(A[i,j]) 是真的，除非 i==j. 请注意，这是没有必要的 A 如果你也想检查一下，你需要检查一下 大小(A,1)==大小(A,2).
*例子*
julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
1 2
2 -1
julia> isdiag(a)
false
julia> b = [im 0; 0 -im]
2×2 Matrix{Complex{Int64}}:
0+1im 0+0im
0+0im 0-1im
julia> isdiag(b)
true
julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
1 0 0
0 2 0
julia> isdiag(c)
true
朱莉娅>d= [1 0 0; 0 2 3]
2×3矩阵{Int64}:
1 0 0
0 2 3
朱莉娅>伊斯迪亚格（d）
错误# *`线性代数。伊瑟米香`*-函数
ishermitian(A) -> Bool测试矩阵是否为Hermitian。
*例子*
julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
1 2
2 -1
julia> ishermitian(a)
true
julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
1+0im 0+1im
0-1im 1+0im
julia> ishermitian(b)
true# *`基地。转置,转置`*-函数
transpose(A)懒转置。 改变返回的对象应该适当地改变 A. 通常，但并非总是如此 转置(A)，在哪里 转置,转置 是一个懒惰的转置包装器。 请注意，此操作是递归的。
此操作用于线性代数的使用-对于一般的数据操作，请参阅 排列,排列，这是非递归的。
*例子*
julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
3 2
0 0
julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
3 0
2 0
julia> B isa Transpose
true
julia> transpose(B) === A # the transpose of a transpose unwraps the parent
true
julia> Transpose(B) # however, the constructor always wraps its argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
3 2
0 0
julia> B[1,2] = 4; # modifying B will modify A automatically
julia> A
2×2 Matrix{Int64}:
3 2
4 0对于复杂矩阵， 伴随,伴随 操作相当于共轭转置。
julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
1+1im 3+3im
2+2im 4+4im
julia> adjoint(A) == conj(transpose(A))
true该 转置,转置 一个 [医]文摘 是行向量:
julia> v = [1,2,3]
3-element Vector{Int64}:
1
2
3
julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
1 2 3
julia>transpose(v)*v#计算点积
14对于矩阵矩阵，单个块递归地操作:
julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
1 3
2 4
julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
[1 3; 2 4] [3 9; 6 12]
[2 6; 4 8] [4 12; 8 16]
julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
[1 2; 3 4] [2 4; 6 8]
[3 6; 9 12] [4 8; 12 16]transpose(F::Factorization)# *`线性代数。换位！`*-函数
transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}转置矩阵 A 并将其存储在矩阵中 X. 尺寸(X) 必须等于 尺寸(转置(A)). 除了调整rowval和nzval的大小之外，不会分配其他内存 X，如果需要的话。
见 半精子！
transpose!(dest,src)转置数组 src公司 并将结果存储在预分配的数组中 德斯特，其应具有对应于 (大小(src,2),大小(src,1)). 不支持就地换位，如果出现以下情况，则会发生意外结果 src公司 和 德斯特 具有重叠的存储器区域。
*例子*
julia> A = [3+2im 9+2im; 8+7im 4+6im]
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
8+7im 4+6im
julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
0+0im 0+0im
0+0im 0+0im
julia> transpose!(B, A);
julia> B
2×2 Matrix{Complex{Int64}}:
3+2im 8+7im
9+2im 4+6im
julia> A
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
8+7im 4+6im# *`线性代数。转座因子化`*-类型
TransposeFactorization底层转置的惰性包装器类型 因式分解 对象。 通常， 转座因子化 构造函数不应该直接调用，使用 转置(::因式分解)代替。
# *`基地。伴随,伴随`*-函数
A'
adjoint(A)Lazy adjoint（共轭转置）。 请注意 [医]附 递归地应用于元素。
对于数字类型, [医]附 返回复共轭，因此它相当于实数的恒等函数。
此操作用于线性代数的使用-对于一般的数据操作，请参阅 排列,排列.
*例子*
julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
0+0im 0+0im
julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
3-2im 0+0im
9-2im 0+0im
julia> B isa Adjoint
true
julia> adjoint(B) === A # the adjoint of an adjoint unwraps the parent
true
julia> Adjoint(B) # however, the constructor always wraps its argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
3+2im 9+2im
0+0im 0+0im
julia>B[1,2]=4+5im;#修改B会自动修改A
朱莉娅>A
2×2矩阵{Complex{Int64}}:
3+2im9+2im
4-5im0+0im对于实矩阵， [医]附 操作相当于一个 转置,转置.
julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
1 3
2 4
julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
1 2
3 4
julia> adjoint(A) == transpose(A)
true一个的伴随 [医]文摘 是行向量:
julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
3 + 0im
0 + 4im
julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
3+0im 0-4im
julia> x'x # compute the dot product, equivalently x' * x
25 + 0im对于矩阵矩阵，单个块递归地操作:
julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
1+1im 3+3im
2+2im 4+4im
julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
[1+1im 3+3im; 2+2im 4+4im] [3+3im 9+9im; 6+6im 12+12im]
[2+2im 6+6im; 4+4im 8+8im] [4+4im 12+12im; 8+8im 16+16im]
julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
[1-1im 2-2im; 3-3im 4-4im] [2-2im 4-4im; 6-6im 8-8im]
[3-3im 6-6im; 9-9im 12-12im] [4-4im 8-8im; 12-12im 16-16im]adjoint(F::Factorization)因式分解的懒惰伴随 F. 默认情况下，返回 辅助因子化包装。
# *`线性代数。伴随！`*-函数
adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}转置矩阵 A 并存储矩阵中元素的邻接 X. 尺寸(X) 必须等于 尺寸(转置(A)). 除了调整rowval和nzval的大小之外，不会分配其他内存 X，如果需要的话。
见 半精子！
adjoint!(dest,src)共轭转置阵列 src公司 并将结果存储在预分配的数组中 德斯特，其应具有对应于 (大小(src,2),大小(src,1)). 不支持就地换位，如果 src公司 和 德斯特 具有重叠的存储器区域。
*例子*
julia> A = [3+2im 9+2im; 8+7im 4+6im]
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
8+7im 4+6im
julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
0+0im 0+0im
0+0im 0+0im
julia> adjoint!(B, A);
julia> B
2×2 Matrix{Complex{Int64}}:
3-2im 8-7im
9-2im 4-6im
julia> A
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
8+7im 4+6im# *`线性代数。辅助因子化`*-类型
AdjointFactorization底层的辅助的惰性包装器类型 因式分解 对象。 通常， 辅助因子化 构造函数不应该直接调用，使用 adjoint(::因式分解)代替。
# *`基地。副本`*-Method
copy(A::Transpose)
copy(A::Adjoint)急切地评估懒惰矩阵转置/伴随。 请注意，转置以递归方式应用于元素。
此操作用于线性代数的使用-对于一般的数据操作，请参阅 排列,排列，这是非递归的。
*例子*
julia> A = [1 2im; -3im 4]
2×2 Matrix{Complex{Int64}}:
1+0im 0+2im
0-3im 4+0im
julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
1+0im 0-3im
0+2im 4+0im
julia> copy(T)
2×2 Matrix{Complex{Int64}}:
1+0im 0-3im
0+2im 4+0im# *`线性代数。跨步1`*-函数
stride1(A) -> Int以元素大小为单位返回维度1中连续数组元素之间的距离。
*例子*
julia> A = [1,2,3,4]
4-element Vector{Int64}:
1
2
3
4
julia> LinearAlgebra.stride1(A)
1
julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
2
4
julia> LinearAlgebra.stride1(B)
2# *`线性代数。支票,支票`*-函数
LinearAlgebra.checksquare(A)检查矩阵是否为正方形，然后返回其公共维度。 对于多个参数，返回一个向量。
*例子*
julia> A = fill(1, (4,4)); B = fill(1, (5,5));
julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
4
5# *`线性代数。[医]尖顶`*-函数
LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)[医]峰顶 使用双精度计算计算机的峰值翻牌率 杰姆！. 默认情况下，如果没有指定参数，它将乘以两个 漂浮64 大小矩阵 n x n，在哪里 n=4096. 如果底层BLAS使用多个线程，则实现更高的翻牌率。 BLAS线程的数量可以设置为 布拉斯。set_num_threads(n).
如果关键字参数 eltype,eltype 被提供, [医]尖顶 将构造具有类型元素的矩阵 eltype,eltype 用于计算峰值翻牌率。
默认情况下, [医]尖顶 将使用3次试验的最佳时机。 如果 n.非典型肺炎 提供关键字参数, [医]峰顶 将使用这些许多试验来选择最佳时机。
如果关键字参数 平行的 被设置为 真的, [医]峰顶 在所有工作处理器上并行运行。 返回整个并行计算机的翻牌率。 并行运行时，只使用10个线程。 论点 n 仍然是指在每个处理器上解决的问题的大小。
|
兼容性
Julia1.1此功能至少需要Julia1.1。 在Julia1.0中，它可以从标准库中获得 |
# *`线性代数。[医]隐士`*-函数
hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian返回方阵的Hermitian部分 A，定义为 (A+A')/2，作为一个 赫米蒂安矩阵。 对于实矩阵 A，这也被称为对称部分 A;它有时也被称为"操作员真实部分"。 可选参数 上升,上升 控制相应的参数 赫米香查看。 对于实矩阵，后者相当于一个 对称查看。
请参阅 hermitianpart！进行相应的就地操作。
|
兼容性
Julia1.10此功能需要Julia1.10或更高版本。 |
# *`线性代数。copy_adjoint！`*-函数
copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B有效地复制矩阵的元素 A 到 B 带形容词如下:
B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]元素 B[ir_dest，jr_dest] 被复盖。 此外，索引范围参数必须满足 长度(ir_dest)==长度(jr_src) 和 长度(jr_dest)==长度(ir_src).
# *`线性代数。copy_transpose！`*-函数
copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B有效地复制矩阵的元素 A 到 B 随着换位如下:
B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]元素 B[ir_dest，jr_dest] 被复盖。 此外，索引范围参数必须满足 长度(ir_dest)==长度(jr_src) 和 长度(jr_dest)==长度(ir_src).
copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
tM::AbstractChar,
M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B有效地复制矩阵的元素 M 到 B 以字符参数为条件 tM 如下:
tM |
目的地 | 资料来源 |
|---|---|---|
|
|
|
|
|
|
|
|
|
元素 B[ir_dest，jr_dest] 被复盖。 此外，索引范围参数必须满足 长度(ir_dest)==长度(jr_src) 和 长度(jr_dest)==长度(ir_src).
请参阅 收到！和 copy_adjoint！.
低级矩阵运算
在许多情况下，矩阵运算的就地版本允许您提供预先分配的输出向量或矩阵。 这在优化关键代码以避免重复分配的开销时非常有用。 这些就地操作的后缀为 ! 下面（例如 穆尔！）按照通常的朱莉娅惯例。
# *`线性代数。穆尔！`*-函数
mul!(Y, A, B) -> Y计算矩阵-矩阵或矩阵-向量积 并将结果存储在 Y，复盖现有的价值 Y. 请注意 Y 不得与任何一个别名 A 或 B.
*例子*
julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);
julia> mul!(Y, A, B) === Y
true
julia> Y
2×2 Matrix{Float64}:
3.0 3.0
7.0 7.0
julia>Y==A*B
真的*实施*
对于自定义矩阵和向量类型，建议实现5参数 穆尔！ 而不是实现3参数 穆尔！ 如果可能的话直接。
mul!(C, A, B, α, β) -> C组合inplace matrix-matrix或matrix-vector multiply-add . 结果存储在 C 通过复盖它。 请注意 C 不得与任何一个别名 A 或 B.
|
兼容性
Julia1.3五论点 |
*例子*
julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];
julia> α, β = 100.0, 10.0;
julia> mul!(C, A, B, α, β) === C
true
julia> C
2×2 Matrix{Float64}:
310.0 320.0
730.0 740.0
julia> C_original = [1.0 2.0; 3.0 4.0]; # A copy of the original value of C
julia> C == A * B * α + C_original * β
true# *`线性代数。lmul!`*-函数
lmul!(a::Number, B::AbstractArray)缩放数组 B 通过标量 a 复盖 B 到位。 使用方法 rmul！从右边乘以标量。 缩放操作尊重乘法的语义 *之间 a 和一个元素 B. 特别是，这也适用于涉及非有限数字的乘法，例如 南 和 ±Inf.
|
兼容性
茱莉亚1.1之前的茱莉亚1.1, |
*例子*
julia> B = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> lmul!(2, B)
2×2 Matrix{Int64}:
2 4
6 8
julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
NaNlmul!(A, B)*例子*
julia> B = [0 1; 1 0];
julia> A = UpperTriangular([1 2; 0 3]);
julia> lmul!(A, B);
julia> B
2×2 Matrix{Int64}:
2 1
3 0
julia> B = [1.0 2.0; 3.0 4.0];
julia> F = qr([0 1; -1 0]);
朱莉娅>lmul！(F.Q,B)
2×2矩阵{Float64}:
3.0 4.0
1.0 2.0# *`线性代数。rmul！`*-函数
rmul!(A::AbstractArray, b::Number)缩放数组 A 通过标量 b 复盖 A 到位。 使用方法 lmul!从左乘以标量。 缩放操作尊重乘法的语义 *之间的一个元素 A 和 b. 特别是，这也适用于涉及非有限数字的乘法，例如 南 和 ±Inf.
|
兼容性
茱莉亚1.1之前的茱莉亚1.1, |
*例子*
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> rmul!(A, 2)
2×2 Matrix{Int64}:
2 4
6 8
julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
NaNrmul!(A, B)*例子*
julia> A = [0 1; 1 0];
julia> B = UpperTriangular([1 2; 0 3]);
朱莉娅>rmul！（A，B）;
朱莉娅>A
2×2矩阵{Int64}:
0 3
1 2
朱莉娅>A=[1.0 2.0;3.0 4.0];
julia>F=qr（[0 1;-1 0]）;
朱莉娅>rmul！(A,F.Q)
2×2矩阵{Float64}:
2.0 1.0
4.0 3.0# *`线性代数。ldiv！`*-函数
ldiv!(Y, A, B) -> Y计算/计算 A\B 就地存储结果 Y，返回结果。
论点 A 应该_not_是矩阵。 相反，它应该是一个因式分解对象（例如由 因式分解或 乔莱斯基). 这样做的原因是因子分解本身既昂贵又通常分配内存（尽管它也可以通过就地完成，例如, xref:stdlib/LinearAlgebra.adoc#LinearAlgebra.lu![鲁！），以及需要性能关键的情况 ldiv！ 通常还需要细粒度控制因式分解 A.
|
注意某些结构化矩阵类型，例如 |
*例子*
julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];
julia> B = [1, 2.5, 3];
julia> Y = similar(B); # use similar since there is no need to read from it
朱莉娅>ldiv！(Y,qr(A),B);#你也可以试试qr！(A)进一步减少拨款
朱莉娅>Y≈A\B
真的ldiv!(A, B)计算/计算 A\B 就地和复盖 B 来存储结果。
论点 A 应该_not_是矩阵。 相反，它应该是一个因式分解对象（例如由 因式分解或 乔莱斯基). 这样做的原因是因子分解本身既昂贵又通常分配内存（尽管它也可以通过就地完成，例如, xref:stdlib/LinearAlgebra.adoc#LinearAlgebra.lu![鲁！），以及需要性能关键的情况 ldiv！ 通常还需要细粒度控制因式分解 A.
|
注意某些结构化矩阵类型，例如 |
*例子*
julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];
julia> B = [1, 2.5, 3];
julia> B0 = copy(B); # a backup copy to facilitate testing
julia> ldiv!(lu(A), B); # you may also try lu!(A) to further reduce allocation
julia> B ≈ A \ B0
trueldiv!(a::Number, B::AbstractArray)划分数组中的每个条目 B 通过标量 a 复盖 B 到位。 使用方法 rdiv！从右边划分标量。
*例子*
julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
朱莉娅>ldiv！(2.0,B)
2×2矩阵{Float64}:
0.5 1.0
1.5 2.0ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B计算/计算 A\B 通过部分旋转的高斯消除就地，并将结果存储在 B，返回结果。 在这个过程中， A 也被复盖。
|
兼容性
朱莉娅1.11 |
# *`线性代数。rdiv！`*-函数
rdiv!(A, B)计算/计算 A/B 就地和复盖 A 来存储结果。
论点 B 应该_not_是矩阵。 相反，它应该是一个因式分解对象（例如由 因式分解或 乔莱斯基). 这样做的原因是因子分解本身既昂贵又通常分配内存（尽管它也可以通过就地完成，例如, xref:stdlib/LinearAlgebra.adoc#LinearAlgebra.lu![鲁！），以及需要性能关键的情况 rdiv！ 通常还需要对因式分解的细粒度控制 B.
|
注意某些结构化矩阵类型，例如 |
rdiv!(A::AbstractArray, b::Number)划分数组中的每个条目 A 通过标量 b 复盖 A 到位。 使用方法 ldiv！从左划分标量。
*例子*
julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
0.5 1.0
1.5 2.0BLAS功能
在Julia中（就像在许多科学计算中一样），密集的线性代数运算基于https://www.netlib.org/lapack/[LAPACK库]，它又建立在基本的线性代数构建块之上，称为https://www.netlib.org/blas每个计算机体系结构都有高度优化的BLAS实现，有时在高性能线性代数例程中，直接调用BLAS函数是很有用的。
线性代数。布拉斯 为某些BLAS函数提供包装器。 那些复盖其中一个输入数组的BLAS函数的名称以 '!'. 通常，BLAS函数定义了四个方法，用于 漂浮物32, 漂浮64, 复杂的32，和 复杂的f64数组。
BLAS字符参数
许多BLAS函数接受确定是否转置参数的参数（反式,反式），引用矩阵的哪个三角形（上升,上升 或 ul认证），三角形矩阵的对角线是否可以假设为所有的（大）或者输入参数属于矩阵乘法的哪一边（侧面). 可能性是:
单位对角线
迪亚格/dX |
意义 |
|---|---|
|
矩阵的对角线值 |
|
矩阵的对角线 |
# *`线性代数。布拉斯`*-模式_
BLAS子例程的接口。
# *`线性代数。布拉斯。set_num_threads`*-函数
set_num_threads(n::Integer)
set_num_threads(::Nothing)设置BLAS库应使用的线程数等于 N::整数.
也接受 什么都没有，在这种情况下，julia试图猜测默认的线程数。 传球 什么都没有 是气馁的，主要是由于历史原因而存在的。
BLAS函数可以分为三组，也称为三级，具体取决于它们首次提出的时间，输入参数的类型以及操作的复杂性。
一级BLAS功能
第1级BLAS功能首次在（https://dl.acm.org/doi/10.1145/355841.355847[Lawson，1979])并定义标量和向量之间的运算。
# *`线性代数。布拉斯。腐烂！`*-函数
rot!(n, X, incx, Y, incy, c, s)复盖 X 与 c*X+s*Y 和 Y 与 -conj(s)*X+c*Y 对于第一 n 数组的元素 X 步履蹒跚 incx公司 首先 n 数组的元素 Y 步履蹒跚 印地安. 申报表 X 和 Y.
|
兼容性
朱莉娅1.5 |
# *`线性代数。布拉斯。斯卡尔！`*-函数
scal!(n, a, X, incx)
scal!(a, X)复盖 X 与 a*X 对于第一 n 数组的元素 X 步履蹒跚 incx公司. 申报表 X.
如果 n 和 incx公司 不提供, 长度(X) 和 步幅(X,1) 被使用。
# *`线性代数。布拉斯。[医]scal`*-函数
scal(n, a, X, incx)
scal(a, X)回来吧 X 按比例缩放 a 对于第一 n 数组的元素 X 步履蹒跚 incx公司.
如果 n 和 incx公司 不提供, 长度(X) 和 步幅(X,1) 被使用。
# *`线性代数。布拉斯。坏蛋！`*-函数
blascopy!(n, X, incx, Y, incy)副本 n 数组的元素 X 步履蹒跚 incx公司 到阵列 Y 步履蹒跚 印地安. 申报表 Y.
# *`线性代数。布拉斯。点`*-函数
dot(n, X, incx, Y, incy)由两个向量组成的点积 n 数组的元素 X 步履蹒跚 incx公司 和 n 数组的元素 Y 步履蹒跚 印地安.
*例子*
julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0# *`线性代数。布拉斯。道图`*-函数
dotu(n, X, incx, Y, incy)两个复数向量的点函数 n 数组的元素 X 步履蹒跚 incx公司 和 n 数组的元素 Y 步履蹒跚 印地安.
*例子*
julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im# *`线性代数。布拉斯。dotc`*-函数
dotc(n, X, incx, U, incy)两个复数向量的点函数，由 n 数组的元素 X 步履蹒跚 incx公司 和 n 数组的元素 U 步履蹒跚 印地安，共轭所述第一载体。
*例子*
julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im# *`线性代数。布拉斯。nrm2`*-函数
nrm2(n, X, incx)2-由 n 数组的元素 X 步履蹒跚 incx公司.
*例子*
julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0
julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0# *`线性代数。布拉斯。阿苏姆`*-函数
asum(n, X, incx)第一个量的总和 n 数组的元素 X 步履蹒跚 incx公司.
对于一个真正的数组，大小是绝对值。 对于复数数组，量值是实部绝对值与虚部绝对值之和。
*例子*
julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0
julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0# *`线性代数。布拉斯。iamax的`*-函数
iamax(n, dx, incx)
iamax(dx)找到元素的索引 dx 具有最大绝对值。 n 是长度的 dx，而 incx公司 是步幅。 如果 n 和 incx公司 未提供，它们假定默认值为 n=长度(dx) 和 incx=stride1（dx）.
二级BLAS功能
第2级BLAS功能发表于(Dongarra，1988)并定义矩阵-向量运算。
*返回向量*
# *`线性代数。布拉斯。hpmv！`*-函数
hpmv!(uplo, α, AP, x, β, y)更新向量 y 作为 α*A*x+β*y，在哪里 A 是以包装格式提供的Hermitian矩阵 美联社.
与 u='U'，阵列AP必须包含依序、逐列打包的Hermitian矩阵的上三角部分，使 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[1,2] 和 A[2,2] 分别，以此类推。
与 uplo='L'，阵列AP必须包含依次、逐列打包的Hermitian矩阵的下三角部分，使得 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[2,1] 和 A[3,1] 分别，以此类推。
标量输入 α 和 β 必须是复数或实数。
阵列输入 x, y 和 美联社 都必须是 复杂的32 或 复杂的f64 类型。
返回更新的 y.
|
兼容性
朱莉娅1.5 |
# *`线性代数。布拉斯。spmv！`*-函数
spmv!(uplo, α, AP, x, β, y)更新向量 y 作为 α*A*x+β*y，在哪里 A 是以打包格式提供的对称矩阵 美联社.
与 u='U'，阵列AP必须包含对称矩阵的上三角部分按顺序、逐列打包，使得 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[1,2] 和 A[2,2] 分别，等等。
与 uplo='L'，阵列AP必须包含对称矩阵的下三角部分按顺序、逐列打包，使得 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[2,1] 和 A[3,1] 分别，等等。
标量输入 α 和 β 一定是真的。
阵列输入 x, y 和 美联社 都必须是 漂浮物32 或 漂浮64 类型。
返回更新的 y.
|
兼容性
朱莉娅1.5 |
*返回矩阵*
# *`线性代数。布拉斯。spr！`*-函数
spr!(uplo, α, x, AP)更新矩阵 A 作为 A+α*x*x'，在哪里 A 是以打包格式提供的对称矩阵 美联社 和 x 是一个向量。
与 u='U'，阵列AP必须包含对称矩阵的上三角部分按顺序、逐列打包，使得 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[1,2] 和 A[2,2] 分别，以此类推。
与 uplo='L'，阵列AP必须包含对称矩阵的下三角部分按顺序、逐列打包，使得 美联社[1] 包含 A[1,1], 美联社[2] 和 美联社[3] 包含 A[2,1] 和 A[3,1] 分别，等等。
标量输入 α 一定是真的。
阵列输入 x 和 美联社 都必须是 漂浮物32 或 漂浮64 类型。 返回更新的 美联社.
|
兼容性
朱莉娅1.8 |
LAPACK功能
线性代数。拉帕克 为线性代数的一些LAPACK函数提供包装。 那些复盖其中一个输入数组的函数的名称以 '!'.
请注意，Julia提供的LAPACK API可以并且将来会发生变化。 由于此API不是面向用户的，因此没有承诺在未来版本中支持/弃用此特定功能集。
# *`线性代数。拉帕克`*-模式_
LAPACK子例程的接口。
# *`线性代数。拉帕克。gbtrf！`*-函数
gbtrf!(kl, ku, m, AB) -> (AB, ipiv)计算带状矩阵的LU因式分解 AB. 九龙区 是包含非零带的第一个子带, 顾 是包含一个的最后一个超二边形，并且 m 是矩阵的第一维 AB. 返回LU因子分解就地和 ipiv，使用的枢轴的矢量。
# *`线性代数。拉帕克。gbtrs！`*-函数
gbtrs!(trans, kl, ku, m, AB, ipiv, B)解方程 AB*X=B. 反式,反式 确定的方向 AB. 它可能是 N （无转置）, T （转置），或 C （共轭转置）。 九龙区 是包含非零带的第一个子带, 顾 是包含一个的最后一个超二边形，并且 m 是矩阵的第一维 AB. ipiv 是从返回的枢轴的矢量 gbtrf！. 返回向量或矩阵 X，复盖 B 到位。
# *`线性代数。拉帕克。格巴尔！`*-函数
gebal!(job, A) -> (ilo, ihi, scale)平衡矩阵 A 在计算其本征系统或Schur因子分解之前。 工作 可以是 N (A 不会被排列或缩放）, P (A 只会被允许）, S (A 只会缩放），或 B (A 将被排列和缩放）。 修改/修改 A 就地和返回 劳工组织, 伊希，而 比例尺. 如果打开了排列, A[i,j]=0 如果 j>i 和 1<j<ilo 或 j>伊希. 比例尺 包含有关执行的缩放/排列的信息。
# *`线性代数。拉帕克。格巴克！`*-函数
gebak!(job, side, ilo, ihi, scale, V)变换特征向量 V 使用矩阵平衡 格巴尔！ 到原始矩阵的未缩放/未拟合的特征向量。 修改/修改 V 到位。 侧面 可以是 L （左特征向量被变换）或 R （右特征向量进行变换）。
# *`线性代数。拉帕克。格布德！`*-函数
gebrd!(A) -> (A, d, e, tauq, taup)减少 A 原位到双角形 A=QBP'. 申报表 A，包含双角矩阵 B; d，包含的对角线元素 B; e，包含的非对角线元素 B; 陶克，包含代表的基本反射器 Q；及 陶普，包含代表的基本反射器 P.
# *`线性代数。拉帕克。gelqf！`*-函数
gelqf!(A, tau)计算 LQ 因式分解 A, A=LQ. 头,头 包含对因式分解的基本反射器进行参数化的标量。 头,头 长度必须大于或等于 A.
申报表 A 和 头,头 就地修改。
gelqf!(A) -> (A, tau)计算 LQ 因式分解 A, A=LQ.
申报表 A、就地修改，以及 头,头，其中包含对因式分解的基本反射器进行参数化的标量。
# *`线性代数。拉帕克。格克尔夫！`*-函数
geqlf!(A, tau)计算 QL 因式分解 A, A=QL. 头,头 包含对因式分解的基本反射器进行参数化的标量。 头,头 长度必须大于或等于 A.
申报表 A 和 头,头 就地修改。
geqlf!(A) -> (A, tau)计算 QL 因式分解 A, A=QL.
申报表 A、就地修改，以及 头,头，其中包含对因式分解的基本反射器进行参数化的标量。
# *`线性代数。拉帕克。geqrf！`*-函数
geqrf!(A, tau)计算 资历名册 因式分解 A, A=QR. 头,头 包含对因式分解的基本反射器进行参数化的标量。 头,头 长度必须大于或等于 A.
申报表 A 和 头,头 就地修改。
geqrf!(A) -> (A, tau)计算 资历名册 因式分解 A, A=QR.
申报表 A、就地修改，以及 头,头，其中包含对因式分解的基本反射器进行参数化的标量。
# *`线性代数。拉帕克。geqp3！`*-函数
geqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)计算枢轴 资历名册 因式分解 A, AP=QR 使用BLAS等级3。 P 是一个枢转矩阵，由 jpvt. 头,头 存储基本反射器。 论点 jpvt 和 头,头 是可选的，并允许传递预分配的数组。 当通过, jpvt 长度必须大于或等于 n 如果 A 是一个 (m x n) 矩阵和 头,头 长度必须大于或等于 A. 入境时，如 jpvt[j] 不等于零则 j第三栏 A 被排列在 美联社.
A, jpvt，而 头,头 被就地修改。
# *`线性代数。拉帕克。格克夫！`*-函数
gerqf!(A, tau)计算 RQ 因式分解 A, A=RQ. 头,头 包含对因式分解的基本反射器进行参数化的标量。 头,头 长度必须大于或等于 A.
申报表 A 和 头,头 就地修改。
gerqf!(A) -> (A, tau)计算 RQ 因式分解 A, A=RQ.
申报表 A、就地修改，以及 头,头，其中包含对因式分解的基本反射器进行参数化的标量。
# *`线性代数。拉帕克。格克特！`*-函数
geqrt!(A, T)计算阻塞 资历名册 因式分解 A, A=QR. T 包含上部三角形块反射器，其参数化因式分解的基本反射器。 第一维的 T 设置块大小，它必须介于1和 n. 第二维的 T 必须等于最小尺寸 A.
申报表 A 和 T 就地修改。
geqrt!(A, nb) -> (A, T)计算阻塞 资历名册 因式分解 A, A=QR. nb 设置块大小，它必须介于1和 n，第二维 A.
申报表 A、就地修改，以及 T，其包含上部三角形块反射器，其参数化因式分解的基本反射器。
# *`线性代数。拉帕克。geqrt3！`*-函数
geqrt3!(A, T)递归计算阻塞 资历名册 因式分解 A, A=QR. T 包含上部三角形块反射器，其参数化因式分解的基本反射器。 第一维的 T 设置块大小，它必须介于1和 n. 第二维的 T 必须等于最小尺寸 A.
申报表 A 和 T 就地修改。
geqrt3!(A) -> (A, T)递归计算阻塞 资历名册 因式分解 A, A=QR.
申报表 A、就地修改，以及 T，其包含上部三角形块反射器，其参数化因式分解的基本反射器。
# *`线性代数。拉帕克。盖特夫！`*-函数
getrf!(A, ipiv) -> (A, ipiv, info)计算枢轴 卢 因式分解 A, A=鲁. ipiv 包含透视信息和 资料 表示成功的代码（信息=0），一个奇异值 U (信息=i，在这种情况下 U[我，我] 是单数），或错误代码（信息<0).
getrf!(A) -> (A, ipiv, info)计算枢轴 卢 因式分解 A, A=鲁.
申报表 A，就地改装, ipiv，所述枢转信息，以及一 资料 表示成功的代码（信息=0），一个奇异值 U (信息=i，在这种情况下 U[我，我] 是单数），或错误代码（信息<0).
# *`线性代数。拉帕克。奥姆兹！`*-函数
ormrz!(side, trans, A, tau, C)乘以矩阵 C 由 Q 来自由 tzrzf！. 视情况而定 侧面 或 反式,反式 乘法可以是左侧的（侧=L,Q*C）或右侧（侧=R,C*Q)和 Q 可以未经修改（反式=N），转置（反式=T），或共轭转置（反式=C). 返回矩阵 C 它是用乘法的结果就地修改的。
# *`线性代数。拉帕克。凝胶！`*-函数
gels!(trans, A, B) -> (F, B, ssr)求解线性方程 A*X=B, 转置(A)*X=B，或 形容词(A)*X=B 使用QR或LQ因子分解。 修改矩阵/向量 B 与溶液就位。 A 被其复盖 资历名册 或 LQ 因式分解。 反式,反式 可能是 N (无修改), T （转置），或 C （共轭转置）。 凝胶！ 搜索最小范数/最小二乘解。 A 可能是低于或超过确定。 解决方案返回 B.
# *`线性代数。拉帕克。gesv！`*-函数
gesv!(A, B) -> (B, A, ipiv)求解线性方程 A*X=B 哪里 A 是使用的方阵 卢 因式分解 A. A 被其复盖 卢 因式分解和 B 被解决方案复盖 X. ipiv 包含 卢 因式分解 A.
# *`线性代数。拉帕克。盖特斯！`*-函数
getrs!(trans, A, ipiv, B)求解线性方程 A*X=B, 转置(A)*X=B，或 形容词(A)*X=B 为广场 A. 修改矩阵/向量 B 与溶液就位。 A 是 卢 因式分解从 盖特夫！，与 ipiv 的枢转信息。 反式,反式 可能是 N （无修改）, T （转置），或 C （共轭转置）。
# *`线性代数。拉帕克。格里！`*-函数
getri!(A, ipiv)计算 A，使用其 卢 因式分解发现 盖特夫！. ipiv 是枢轴信息输出和 A 包含 卢 因式分解 盖特夫！. A 被其逆复盖。
# *`线性代数。拉帕克。gesvx！`*-函数
gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)求解线性方程 A*X=B (反式=N), 转置(A)*X=B (反式=T)，或 形容词(A)*X=B (反式=C)使用 卢 因式分解 A. 事实 可能是 E，在这种情况下 A 将被平衡并复制到 AF; F，在这种情况下 AF 和 ipiv 从以前的 卢 因式分解是输入；或 N，在这种情况下 A 将被复制到 AF 然后考虑因素。 如果 事实=F, 相等的,相等的 可能是 N，意思 A 还没有平衡; R，意思 A 被乘以 对角线(R) 从左边; C，意思 A 被乘以 对角线(C) 从右边起；或 B，意思 A 被乘以 对角线(R) 从左边和 对角线(C) 从右边。 如果 事实=F 和 equed=R 或 B 的元素 R 必须都是积极的。 如果 事实=F 和 equed=C 或 B 的元素 C 必须都是积极的。
返回解决方案 X; 相等的,相等的，这是一个输出，如果 事实 不是 N，并描述了所进行的平衡; R，行平衡对角线; C，柱平衡对角线; B，这可能会被其平衡形式复盖 对角线(R)*B （如果 反式=N 和 equed=R，B)或 对角线(C)*B （如果 反式=T，C 和 equed=C，B); rcond的，倒数条件数 A equilbrating后; 费尔，每个解向量的前向误差在 X; 贝尔，每个解向量的前向误差在 X；及 工作，倒数枢轴生长因子。
gesvx!(A, B)无平衡，无转置简化 gesvx！.
# *`线性代数。拉帕克。格尔斯德！`*-函数
gelsd!(A, B, rcond) -> (B, rnk)计算的最小范数解 A*X=B 通过找到 SVD 因式分解 A，然后分割和征服问题。 B 被解决方案复盖 X. 下面的奇异值 rcond的 将被视为零。 返回解决方案 B 和有效等级 A 在 rnk.
# *`线性代数。拉帕克。盖尔西！`*-函数
gelsy!(A, B, rcond) -> (B, rnk)计算的最小范数解 A*X=B 通过找到完整的 资历名册 因式分解 A，然后分割和征服问题。 B 被解决方案复盖 X. 下面的奇异值 rcond的 将被视为零。 返回解决方案 B 和有效等级 A 在 rnk.
# *`线性代数。拉帕克。格尔斯！`*-函数
gglse!(A, c, B, d) -> (X,res)求解方程 A*x=c 哪里 x 受平等约束 B*x=d. 使用公式 //c-A*x//^2=0 来解决。 申报表 X 和残差平方和。
# *`线性代数。拉帕克。天啊！`*-函数
geev!(jobvl, jobvr, A) -> (W, VL, VR)找到 A. 如果 jobvl=N，的左特征向量 A 没有计算。 如果 jobvr=N，右特征向量 A 没有计算。 如果 jobvl=V 或 jobvr=V，计算出相应的特征向量。 返回特征值 W，右特征向量在 VR/VR，和左特征向量在 VL.
# *`线性代数。拉帕克。gesdd！`*-函数
gesdd!(job, A) -> (U, S, VT)求奇异值分解 A, A=U*S*V'，采用分而治之的方法。 如果 工作=A，所有的列 U 和行 V' 进行计算。 如果 工作=N，没有列 U 或行 V' 进行计算。 如果 工作=O, A 被（thin）的列复盖 U 和行（薄） V'. 如果 工作=S，（薄）的列 U 和行（薄） V' 分别计算并返回。
# *`线性代数。拉帕克。gesvd！`*-函数
gesvd!(jobu, jobvt, A) -> (U, S, VT)求奇异值分解 A, A=U*S*V'. 如果 jobu=A，所有的列 U 进行计算。 如果 jobvt=一个 所有的行 V' 进行计算。 如果 jobu=N，没有列 U 进行计算。 如果 jobvt=N 没有行 V' 进行计算。 如果 乔布=O, A 被（thin）的列复盖 U. 如果 jobvt=O, A 用（瘦）的行复盖 V'. 如果 jobu=S，列（薄） U 分别计算并返回。 如果 jobvt=S （薄）的行 V' 分别计算并返回。 乔布 和 工作/工作 不能都是 O.
申报表 U, S，而 Vt;Vt，在哪里 S 是奇异值 A.
# *`线性代数。拉帕克。ggsvd！`*-函数
ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)求广义奇异值分解 A 和 B, U'*A*Q=D1*R 和 V'*B*Q=D2*R. D1 有 阿尔法 在其对角线和 D2 有 贝塔 在其对角线上。 如果 jobu=U，正交/酉矩阵 U 被计算。 如果 jobv=V 正交/酉矩阵 V 被计算。 如果 jobq=Q，正交/酉矩阵 Q 被计算。 如果 乔布, 约伯 或 职位q 是 N，该矩阵不计算。 此功能仅在3.6.0之前的LAPACK版本中可用。
# *`线性代数。拉帕克。ggsvd3！`*-函数
ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)求广义奇异值分解 A 和 B, U'*A*Q=D1*R 和 V'*B*Q=D2*R. D1 有 阿尔法 在其对角线和 D2 有 贝塔 在其对角线上。 如果 jobu=U，正交/酉矩阵 U 被计算。 如果 jobv=V 正交/酉矩阵 V 被计算。 如果 jobq=Q，正交/酉矩阵 Q 被计算。 如果 乔布, 约伯，或 职位q 是 N，该矩阵不计算。 此功能需要LAPACK3.6.0。
# *`线性代数。拉帕克。天啊！`*-函数
geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)找到 A 用矩阵平衡。 如果 jobvl=N，的左特征向量 A 没有计算。 如果 jobvr=N，右特征向量 A 没有计算。 如果 jobvl=V 或 jobvr=V，计算出相应的特征向量。 如果 balanc=N，不进行平衡。 如果 balanc=P, A 被排列但不缩放。 如果 巴兰克=S, A 被缩放但不被排列。 如果 balanc=B, A 被排列和缩放。 如果 感=N，不计算倒数条件数。 如果 感=E，倒数条件数仅针对特征值计算。 如果 感=V，倒数条件数仅针对右特征向量计算。 如果 感=B，计算右本征向量和本征向量的倒数条件数。 如果 感=E,B，必须计算右和左特征向量。
# *`线性代数。拉帕克。ggev！`*-函数
ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)找到 A 和 B. 如果 jobvl=N，左特征向量不计算。 如果 jobvr=N，没有计算正确的特征向量。 如果 jobvl=V 或 jobvr=V，计算出相应的特征向量。
# *`线性代数。拉帕克。ggev3！`*-函数
ggev3!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)找到 A 和 B 使用阻塞算法。 如果 jobvl=N，左特征向量不计算。 如果 jobvr=N，没有计算正确的特征向量。 如果 jobvl=V 或 jobvr=V，计算出相应的特征向量。 此功能需要LAPACK3.6.0。
# *`线性代数。拉帕克。gtsv！`*-函数
gtsv!(dl, d, du, B)求解方程 A*X=B 哪里 A 是一个三棱柱矩阵与 dl 在细分上, d 在对角线上，和 杜 在超斜角上。
复盖 B 与解决方案 X 并将其返回。
# *`线性代数。拉帕克。gttrf！`*-函数
gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)找到 卢 三边形矩阵的因式分解 dl 在细分上, d 在对角线上，和 杜 在超斜角上。
修改/修改 dl, d，而 杜 就地并返回它们和第二个超二角 杜2 和枢转向量 ipiv.
# *`线性代数。拉帕克。gttrs！`*-函数
gttrs!(trans, dl, d, du, du2, ipiv, B)求解方程 A*X=B (反式=N), 转置(A)*X=B (反式=T)，或 形容词(A)*X=B (反式=C)使用 卢 因式分解由 gttrf！. B 被解决方案复盖 X.
# *`线性代数。拉帕克。orglq！`*-函数
orglq!(A, tau, k = length(tau))显式查找矩阵 Q 一个 LQ 调用后的因子分解 gelqf！ 上 A. 使用的输出 gelqf！. A 被复盖 Q.
# *`线性代数。拉帕克。orgqr！`*-函数
orgqr!(A, tau, k = length(tau))显式查找矩阵 Q 一个 资历名册 调用后的因子分解 geqrf！ 上 A. 使用的输出 geqrf！. A 被复盖 Q.
# *`线性代数。拉帕克。orgql！`*-函数
orgql!(A, tau, k = length(tau))显式查找矩阵 Q 一个 QL 调用后的因子分解 格克尔夫！ 上 A. 使用的输出 盖克尔夫！. A 被复盖 Q.
# *`线性代数。拉帕克。orgrq！`*-函数
orgrq!(A, tau, k = length(tau))显式查找矩阵 Q 一个 RQ 调用后的因子分解 格克夫！ 上 A. 使用的输出 格克夫！. A 被复盖 Q.
# *`线性代数。拉帕克。ormlq！`*-函数
ormlq!(side, trans, A, tau, C)计算机 Q*C (反式=N), 转置(Q)*C (反式=T), adjoint(Q)*C (反式=C)为 边=L 或等效的右侧乘法为 侧=R 使用 Q 从一个 LQ 因式分解 A 使用 gelqf！. C 被复盖。
# *`线性代数。拉帕克。ormqr！`*-函数
ormqr!(side, trans, A, tau, C)计算机 Q*C (反式=N), 转置(Q)*C (反式=T), adjoint(Q)*C (反式=C)为 边=L 或等效的右侧乘法为 侧=R 使用 Q 从一个 资历名册 因式分解 A 使用 geqrf！. C 被复盖。
# *`线性代数。拉帕克。ormql！`*-函数
ormql!(side, trans, A, tau, C)计算机 Q*C (反式=N), 转置(Q)*C (反式=T), adjoint(Q)*C (反式=C)为 边=L 或等效的右侧乘法为 侧=R 使用 Q 从一个 QL 因式分解 A 使用 盖克尔夫！. C 被复盖。
# *`线性代数。拉帕克。ormrq！`*-函数
ormrq!(side, trans, A, tau, C)计算机 Q*C (反式=N), 转置(Q)*C (反式=T), adjoint(Q)*C (反式=C)为 边=L 或等效的右侧乘法为 侧=R 使用 Q 从一个 RQ 因式分解 A 使用 格克夫！. C 被复盖。
# *`线性代数。拉帕克。gemqrt！`*-函数
gemqrt!(side, trans, V, T, C)计算机 Q*C (反式=N), 转置(Q)*C (反式=T), adjoint(Q)*C (反式=C)为 边=L 或等效的右侧乘法为 侧=R 使用 Q 从一个 资历名册 因式分解 A 使用 格克特！. C 被复盖。
# *`线性代数。拉帕克。posv！`*-函数
posv!(uplo, A, B) -> (A, B)找到解决方案 A*X=B 哪里 A 是对称或Hermitian正定矩阵。 如果 u=U 上部Cholesky分解 A 被计算。 如果 升=L 下Cholesky分解 A 被计算。 A 被其Cholesky分解复盖。 B 被解决方案复盖 X.
# *`线性代数。拉帕克。波特里！`*-函数
potri!(uplo, A)计算正定矩阵的逆 A 打电话后 波特夫！ 找到它的（上if u=U，降低如果 升=L）Cholesky分解。
A 被其逆复盖并返回。
# *`线性代数。拉帕克。波特斯！`*-函数
potrs!(uplo, A, B)找到解决方案 A*X=B 哪里 A 是一个对称或Hermitian正定矩阵，其Cholesky分解由 波特夫！. 如果 u=U 上部Cholesky分解 A 是计算出来的。 如果 上升=L 下Cholesky分解 A 是计算出来的。 B 被解决方案复盖 X.
# *`线性代数。拉帕克。pstrf！`*-函数
pstrf!(uplo, A, tol) -> (A, piv, rank, info)计算（上if u=U，降低如果 升=L)正定矩阵的枢转Cholesky分解 A 具有用户设置的容差 托尔. A 被其Cholesky分解复盖。
申报表 A，枢轴 piv，军衔 A，及一 资料 密码。 如果 信息=0，因式分解成功。 如果 信息=i>0，则 A 是不确定的或等级缺陷的。
# *`线性代数。拉帕克。ptsv！`*-函数
ptsv!(D, E, B)解决问题 A*X=B 对于正定tridiagonal A. D 是对角线的 A 和 E 是对角线外。 B 被解决方案复盖 X 然后回来了。
# *`线性代数。拉帕克。pttrs！`*-函数
pttrs!(D, E, B)解决问题 A*X=B 对于正定tridiagonal A 与对角线 D 和非对角线 E 计算后 A使用LDLt因子分解 pttrf！. B 被解决方案复盖 X.
# *`线性代数。拉帕克。崔特里！`*-函数
trtri!(uplo, diag, A)求(upper if)的倒数 u=U，降低如果 升=L)三角矩阵 A. 如果 diag=N, A 具有非单位对角线元素。 如果 diag=U，所有对角线元素 A 是一个。 A 被其逆复盖。
# *`线性代数。拉帕克。trtrs！`*-函数
trtrs!(uplo, trans, diag, A, B)解决问题 A*X=B (反式=N), 转置(A)*X=B (反式=T)，或 形容词(A)*X=B (反式=C)for(upper if u=U，降低如果 上升=L)三角矩阵 A. 如果 diag=N, A 具有非单位对角线元素。 如果 diag=U，所有对角线元素 A 是一个。 B 被解决方案复盖 X.
# *`线性代数。拉帕克。特康！`*-函数
trcon!(norm, uplo, diag, A)查找（upper if）的倒数条件编号 u=U，降低如果 升=L)三角矩阵 A. 如果 diag=N, A 具有非单位对角线元素。 如果 diag=U，所有对角线元素 A 是一个。 如果 规范=I，条件数在无穷范数中找到。 如果 范数=O 或 1，条件编号在一个范数中找到。
# *`线性代数。拉帕克。特雷维克！`*-函数
trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))找到上三角矩阵的本征系统 T. 如果 侧=R，计算右特征向量。 如果 边=L，计算左特征向量。 如果 边=B，这两个集合都是计算的。 如果 howmny=一个，找到所有特征向量。 如果 howmny=B，所有特征向量被发现并使用反向转换 VL 和 VR/VR. 如果 howmny=S，只有对应于在值的特征向量 选择 进行计算。
# *`线性代数。拉帕克。trrfs！`*-函数
trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)估计解决方案中的误差 A*X=B (反式=N), 转置(A)*X=B (反式=T), 形容词(A)*X=B (反式=C)为 边=L，或等效方程一个右手 侧=R X*A 计算后 X 使用 trtrs！. 如果 u=U, A 是上三角形。 如果 升=L, A 是较低的三角形。 如果 diag=N, A 具有非单位对角线元素。 如果 diag=U，所有对角线元素 A 是一个。 费尔 和 贝尔 是可选输入。 费尔 是正向误差和 贝尔 是向后错误，每个组件。
# *`线性代数。拉帕克。史蒂夫！`*-函数
stev!(job, dv, ev) -> (dv, Zmat)计算对称三边形矩阵的本征系统 dv 作为对角线和 电动车 作为非对角线。 如果 工作=N 只有特征值被发现并返回 dv. 如果 工作=V 然后特征向量也被找到并返回 Zmat.
# *`线性代数。拉帕克。斯特布兹！`*-函数
stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)计算对称三边形矩阵的特征值 dv 作为对角线和 电动车 作为非对角线。 如果 范围=A，找到所有的特征值。 如果 范围=V，半开区间内的特征值 (vl，vu] 被发现了。 如果 范围=I，具有指数之间的特征值 伊尔 和 iu 被发现了。 如果 顺序=B，特征值在一个块内排序。 如果 顺序=E，他们被命令跨越所有的块。 阿布斯托尔 可以设置为收敛的容差。
# *`线性代数。拉帕克。斯蒂格！`*-函数
stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)计算特征值（jobz=N）或特征值和特征向量（jobz=V）对于对称的三棱柱矩阵与 dv 作为对角线和 电动车 作为非对角线。 如果 范围=A，找到所有的特征值。 如果 范围=V，半开区间内的特征值 (vl，vu] 被发现了。 如果 范围=I，具有指数之间的特征值 伊尔 和 iu 被发现了。 特征值在返回 w 和特征向量在 Z.
# *`线性代数。拉帕克。斯坦！`*-函数
stein!(dv, ev_in, w_in, iblock_in, isplit_in)计算对称三边形矩阵的特征向量 dv 作为对角线和 ev_in 作为非对角线。 w_in 指定要为其查找相应特征向量的输入特征值。 伊布洛克 指定与 w_in. isplit_in 指定子矩阵块之间的分割点。
# *`线性代数。拉帕克。赛康夫！`*-函数
syconv!(uplo, A, ipiv) -> (A, work)转换对称矩阵 A （已因式分解成三角形矩阵）成两个矩阵 L 和 D. 如果 u=U, A 是上三角形。 如果 升=L，为下三角形。 ipiv 是来自三角因式分解的枢轴矢量。 A 被复盖 L 和 D.
# *`线性代数。拉帕克。sysv！`*-函数
sysv!(uplo, A, B) -> (B, A, ipiv)找到解决方案 A*X=B 对于对称矩阵 A. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。 B 被解决方案复盖 X. A 被它的一堆-考夫曼因子分解复盖。 ipiv 包含有关因子分解的透视信息。
# *`线性代数。拉帕克。赛特夫！`*-函数
sytrf!(uplo, A) -> (A, ipiv, info)计算对称矩阵的束-考夫曼因式分解 A. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。
申报表 A，由因式分解复盖，一个枢轴向量 ipiv，以及错误代码 资料 其为非负整数。 如果 资料 是正的矩阵是奇异的，并且因式分解的对角线部分在位置上正好为零 资料.
sytrf!(uplo, A, ipiv) -> (A, ipiv, info)计算对称矩阵的束-考夫曼因式分解 A. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。
申报表 A，由因式分解复盖，枢轴向量 ipiv，以及错误代码 资料 其为非负整数。 如果 资料 是正的矩阵是奇异的，并且因式分解的对角线部分在位置上正好为零 资料.
# *`线性代数。拉帕克。赛特里！`*-函数
sytri!(uplo, A, ipiv)计算对称矩阵的逆 A 使用的结果 赛特夫！. 如果 u=U，上半部分 A 被存储。 如果 上升=L，下半部分被存储。 A 被其逆复盖。
# *`线性代数。拉帕克。系统！`*-函数
sytrs!(uplo, A, ipiv, B)求解方程 A*X=B 对于对称矩阵 A 使用的结果 赛特夫！. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。 B 被解决方案复盖 X.
# *`线性代数。拉帕克。赫斯夫！`*-函数
hesv!(uplo, A, B) -> (B, A, ipiv)找到解决方案 A*X=B 对于Hermitian矩阵 A. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。 B 被解决方案复盖 X. A 被它的一堆-考夫曼因子分解复盖。 ipiv 包含有关因子分解的透视信息。
# *`线性代数。拉帕克。赫特夫！`*-函数
hetrf!(uplo, A) -> (A, ipiv, info)计算Hermitian矩阵的Bunch-Kaufman因式分解 A. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。
申报表 A，由因式分解复盖，一个枢轴向量 ipiv，以及错误代码 资料 其为非负整数。 如果 资料 是正的矩阵是奇异的，并且因式分解的对角线部分在位置上正好为零 资料.
hetrf!(uplo, A, ipiv) -> (A, ipiv, info)计算Hermitian矩阵的Bunch-Kaufman因式分解 A. 如果 u=U，上半部分 A 被存储。 如果 上升=L，下半部分被存储。
申报表 A，由因式分解复盖，枢轴向量 ipiv，以及错误代码 资料 其为非负整数。 如果 资料 是正的矩阵是奇异的，并且因式分解的对角线部分在位置上正好为零 资料.
# *`线性代数。拉帕克。海特里！`*-函数
hetri!(uplo, A, ipiv)计算Hermitian矩阵的逆 A 使用的结果 赛特夫！. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。 A 被其逆复盖。
# *`线性代数。拉帕克。赫特斯！`*-函数
hetrs!(uplo, A, ipiv, B)求解方程 A*X=B 对于一个Hermitian矩阵 A 使用的结果 赛特夫！. 如果 u=U，上半部分 A 被存储。 如果 升=L，下半部分被存储。 B 被解决方案复盖 X.
# *`线性代数。拉帕克。赛耶夫！`*-函数
syev!(jobz, uplo, A)找到特征值（jobz=N）或特征值和特征向量（jobz=V)的对称矩阵 A. 如果 u=U，的上三角 A 被使用。 如果 升=L，的下三角 A 被使用。
# *`线性代数。拉帕克。syevr！`*-函数
syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)找到特征值（jobz=N）或特征值和特征向量（jobz=V)的对称矩阵 A. 如果 u=U，的上三角 A 被使用。 如果 升=L，的下三角 A 被使用。 如果 范围=A，找到所有的特征值。 如果 范围=V，半开区间内的特征值 (vl，vu] 被发现了。 如果 范围=I，具有指数之间的特征值 伊尔 和 iu 被发现了。 阿布斯托尔 可以设置为收敛的容差。
特征值在返回 W 和特征向量在 Z.
# *`线性代数。拉帕克。赛夫德！`*-函数
syevd!(jobz, uplo, A)找到特征值（jobz=N）或特征值和特征向量（jobz=V)的对称矩阵 A. 如果 u=U，的上三角 A 被使用。 如果 升=L，的下三角 A 被使用。
# *`线性代数。拉帕克。赛格德！`*-函数
sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)求广义特征值（jobz=N）或特征值和特征向量（jobz=V)的对称矩阵 A 和对称正定矩阵 B. 如果 u=U，的上部三角形 A 和 B 被使用。 如果 升=L，的下部三角形 A 和 B 被使用。 如果 itype=1，要解决的问题是 A*x=lambda*B*x. 如果 itype=2，要解决的问题是 A*B*x=lambda*x. 如果 itype=3，要解决的问题是 B*A*x=lambda*x.
# *`线性代数。拉帕克。bdsqr！`*-函数
bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)计算双角矩阵的奇异值分解 d 在对角线和 e_ 在非对角线上。 如果 u=U, e_ 是超二角形。 如果 升=L, e_ 是细分。 也可以选择计算产品 Q'*C.
返回奇异值 d，和矩阵 C 用复盖 Q'*C.
# *`线性代数。拉帕克。bdsdc！`*-函数
bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)计算双角矩阵的奇异值分解 d 在对角线和 e_ 在非对角线上使用divide and conqueq方法。 如果 u=U, e_ 是超二角形。 如果 升=L, e_ 是细分。 如果 compq=N，只找到奇异值。 如果 compq=I，求出奇异值和向量。 如果 compq=P，奇异值和向量以紧凑形式找到。 仅适用于真实类型。
返回奇异值 d，如果 compq=P，紧凑奇异向量在 智商.
# *`线性代数。拉帕克。壁虎！`*-函数
gecon!(normtype, A, anorm)求矩阵的倒数条件数 A. 如果 normtype=I，条件数在无穷范数中找到。 如果 normtype=O 或 1，条件编号在一个范数中找到。 A 必须是结果 盖特夫！ 和 阿诺姆 是规范的 A 在相关规范中。
# *`线性代数。拉帕克。哎呀！`*-函数
gehrd!(ilo, ihi, A) -> (A, tau)转换矩阵 A 到赫森伯格表格。 如果 A 是平衡与 格巴尔！ 然后 劳工组织 和 伊希 是输出 格巴尔！. 否则他们应该是 劳工组织=1 和 ihi=尺寸(A,2). 头,头 包含因式分解的基本反射器。
# *`线性代数。拉帕克。奥格尔！`*-函数
orghr!(ilo, ihi, A, tau)显式查找 Q，正交/酉矩阵从 哎呀！. 劳工组织, 伊希, A，而 头,头 必须对应于输入/输出到 哎呀！.
# *`线性代数。拉帕克。吉斯！`*-函数
gees!(jobvs, A) -> (A, vs, w)计算特征值（jobvs=N）或特征值和Schur向量（jobvs=V)矩阵 A. A 被其Schur形式复盖。
申报表 A, vs的 含所述两个载体，和 w，包含所述特征值。
# *`线性代数。拉帕克。格斯！`*-函数
gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)计算广义特征值，广义舒尔形式，左舒尔向量（jobsvl=V），或右Schur向量（jobvsr=V)的 A 和 B.
广义特征值返回于 阿尔法 和 贝塔. 左Schur向量返回在 vsl的 和右Schur向量返回在 噪音感应强的地方.
# *`线性代数。拉帕克。ges3！`*-函数
gges3!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)计算广义特征值，广义舒尔形式，左舒尔向量（jobsvl=V），或右Schur向量（jobvsr=V)的 A 和 B 使用阻塞算法。 此功能需要LAPACK3.6.0。
广义特征值返回于 阿尔法 和 贝塔. 左Schur向量返回在 vsl的 和右Schur向量返回在 噪音感应强的地方.
# *`线性代数。拉帕克。特雷克斯！`*-函数
trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)重新排序Schur因子分解 T 矩阵的对角线块 T 带行索引 ifst 移动到行索引 伊尔斯特. 如果 compq=V,的Schur向量 Q 被重新排序。 如果 compq=N 它们没有被修改。 4-arg方法调用5-arg方法 compq=V.
# *`线性代数。拉帕克。特森！`*-函数
trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)重新排序矩阵的Schur因子分解，并可选地找到倒数条件编号。 如果 工作=N，没有找到条件编号。 如果 工作=E，只找到这一簇特征值的条件编号。 如果 工作=V，只找到不变子空间的条件编号。 如果 工作=B 然后找到聚类和子空间的条件编号。 如果 compq=V 舒尔向量 Q 进行更新。 如果 compq=N 这些载体不被修饰。 选择 确定哪些特征值在聚类中。 3-arg方法调用5-arg方法 工作=N 和 compq=V.
申报表 T, Q，重新排序的特征值在 w，特征值的簇的条件号 s，以及不变子空间的条件编号 九月.
# *`线性代数。拉帕克。tgsen！`*-函数
tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)对广义Schur分解的向量重新排序。 选择 指定每个聚类中的特征值。
# *`线性代数。拉帕克。特西尔！`*-函数
trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)求解西尔维斯特矩阵方程 A*X+/-X*B=比例*C 哪里 A 和 B 均为准上三角形。 如果 transa=N, A 未被修改。 如果 transa=T, A 被换位。 如果 transa=C, A 是共轭转位的。 同样为 运输及工务局 和 B. 如果 isgn=1，方程 A*X+X*B=比例*C 解决了。 如果 isgn=-1，方程 A*X-X*B=比例*C 解决了。
申报表 X （复盖 C)和 比例尺.
# *`线性代数。拉帕克。hseqr！`*-函数
hseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)计算所有特征值和（可选）还原为Hessenberg形式的矩阵的Schur因子分解。 如果 H 是平衡与 格巴尔！ 然后 劳工组织 和 伊希 是输出 格巴尔！. 否则他们应该是 劳工组织=1 和 ihi=大小(H,2). 头,头 包含因式分解的基本反射器。