Linear Algebra

除了（且作为一部分）对多维数组的支持，Julia 还提供了许多常见和实用的线性代数运算的本地实现，可通过 using LinearAlgebra 加载。 基本的运算，比如 tr，det 和 inv 都是支持的：

1. julia> A = [1 2 3; 4 1 6; 7 8 1]
2. 3×3 Matrix{Int64}:
3. 1  2  3
4. 4  1  6
5. 7  8  1

7. julia> tr(A)
8. 3

10. julia> det(A)
11. 104.0

13. julia> inv(A)
14. 3×3 Matrix{Float64}:
15. -0.451923   0.211538    0.0865385
16. 0.365385  -0.192308    0.0576923
17. 0.240385   0.0576923  -0.0673077

还有其它实用的运算，比如寻找特征值或特征向量：

1. julia> A = [-4. -17.; 2. 2.]
2. 2×2 Matrix{Float64}:
3. -4.0  -17.0
4. 2.0    2.0

6. julia> eigvals(A)
7. 2-element Vector{ComplexF64}:
8. -1.0 - 5.0im
9. -1.0 + 5.0im

11. julia> eigvecs(A)
12. 2×2 Matrix{ComplexF64}:
13. 0.945905-0.0im        0.945905+0.0im
14. -0.166924+0.278207im  -0.166924-0.278207im

此外，Julia 提供了多种矩阵分解，通过将矩阵预先分解成更适合问题的形式（出于性能或内存上的原因），它们可用于加快问题的求解，如线性求解或矩阵求幂。更多有关信息请参阅文档 factorize。举个例子：

1. julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
2. 3×3 Matrix{Float64}:
3. 1.5   2.0  -4.0
4. 3.0  -1.0  -6.0
5. -10.0   2.3   4.0

7. julia> factorize(A)
8. LU{Float64, Matrix{Float64}}
9. L factor:
10. 3×3 Matrix{Float64}:
11. 1.0    0.0       0.0
12. -0.15   1.0       0.0
13. -0.3   -0.132196  1.0
14. U factor:
15. 3×3 Matrix{Float64}:
16. -10.0  2.3     4.0
17. 0.0  2.345  -3.4
18. 0.0  0.0    -5.24947

因为 A 不是埃尔米特、对称、三角、三对角或双对角矩阵，LU 分解也许是我们能做的最好分解。与之相比：

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Matrix{Float64}:
3. 1.5   2.0  -4.0
4. 2.0  -1.0  -3.0
5. -4.0  -3.0   5.0

7. julia> factorize(B)
8. BunchKaufman{Float64, Matrix{Float64}}
9. D factor:
10. 3×3 Tridiagonal{Float64, Vector{Float64}}:
11. -1.64286   0.0   ⋅
12. 0.0      -2.8  0.0
13. ⋅        0.0  5.0
14. U factor:
15. 3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
16. 1.0  0.142857  -0.8
17. ⋅   1.0       -0.6
18. ⋅    ⋅         1.0
19. permutation:
20. 3-element Vector{Int64}:
21. 1
22. 2
23. 3

在这里，Julia 能够发现 B 确实是对称矩阵，并且使用一种更适当的分解。针对一个具有某些属性的矩阵，比如一个对称或三对角矩阵，往往有可能写出更高效的代码。Julia 提供了一些特殊的类型好让你可以根据矩阵所具有的属性「标记」它们。例如：

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Matrix{Float64}:
3. 1.5   2.0  -4.0
4. 2.0  -1.0  -3.0
5. -4.0  -3.0   5.0

7. julia> sB = Symmetric(B)
8. 3×3 Symmetric{Float64, Matrix{Float64}}:
9. 1.5   2.0  -4.0
10. 2.0  -1.0  -3.0
11. -4.0  -3.0   5.0

sB 已经被标记成（实）对称矩阵，所以对于之后可能在它上面执行的操作，例如特征因子化或矩阵-向量乘积，只引用矩阵的一半可以提高效率。举个例子：

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Matrix{Float64}:
3. 1.5   2.0  -4.0
4. 2.0  -1.0  -3.0
5. -4.0  -3.0   5.0

7. julia> sB = Symmetric(B)
8. 3×3 Symmetric{Float64, Matrix{Float64}}:
9. 1.5   2.0  -4.0
10. 2.0  -1.0  -3.0
11. -4.0  -3.0   5.0

13. julia> x = [1; 2; 3]
14. 3-element Vector{Int64}:
15. 1
16. 2
17. 3

19. julia> sB\x
20. 3-element Vector{Float64}:
21. -1.7391304347826084
22. -1.1086956521739126
23. -1.4565217391304346

\ 运算在这里执行线性求解。左除运算符相当强大，很容易写出紧凑、可读的代码，它足够灵活，可以求解各种线性方程组。

特殊矩阵

具有特殊对称性和结构的矩阵经常在线性代数中出现并且与各种矩阵分解相关。 Julia 具有丰富的特殊矩阵类型，可以快速计算专门为特定矩阵类型开发的专用例程。

下表总结了在 Julia 中已经实现的特殊矩阵类型，以及为它们提供各种优化方法的钩子在 LAPACK 中是否可用。

基本运算

Legend:

矩阵分解

图例：

均匀缩放运算符

UniformScaling 运算符代表一个标量乘以单位运算符，λ*I。 单位运算符 I 被定义为常量，是 UniformScaling 的实例。 这些运算符的大小是通用的，并且会在二元运算符 +，-，* 和 [](/read/Julia-1.7-zh/b03d1d5dc0f200e1.md#Base.:\-Tuple{Any, Any}) 中与另一个矩阵相匹配。 对于 A+I 和 A-I ，这意味着 A 必须是个方阵。 与单位运算符 I 相乘是一个空操作（除了检查比例因子是一），因此几乎没有开销。

来查看 UniformScaling 运算符的运行结果：

1. julia> U = UniformScaling(2);

3. julia> a = [1 2; 3 4]
4. 2×2 Matrix{Int64}:
5. 1  2
6. 3  4

8. julia> a + U
9. 2×2 Matrix{Int64}:
10. 3  2
11. 3  6

13. julia> a * U
14. 2×2 Matrix{Int64}:
15. 2  4
16. 6  8

18. julia> [a U]
19. 2×4 Matrix{Int64}:
20. 1  2  2  0
21. 3  4  0  2

23. julia> b = [1 2 3; 4 5 6]
24. 2×3 Matrix{Int64}:
25. 1  2  3
26. 4  5  6

28. julia> b - U
29. ERROR: DimensionMismatch("matrix is not square: dimensions are (2, 3)")
30. Stacktrace:
31. [...]

If you need to solve many systems of the form (A+μI)x = b for the same A and different μ, it might be beneficial to first compute the Hessenberg factorization F of A via the hessenberg function. Given F, Julia employs an efficient algorithm for (F+μ*I) \ b (equivalent to (A+μ*I)x \ b) and related operations like determinants.

Matrix factorizations

Matrix factorizations (a.k.a. matrix decompositions) compute the factorization of a matrix into a product of matrices, and are one of the central concepts in linear algebra.

The following table summarizes the types of matrix factorizations that have been implemented in Julia. Details of their associated methods can be found in the Standard functions section of the Linear Algebra documentation.

Standard functions

Linear algebra functions in Julia are largely implemented by calling functions from LAPACK. Sparse matrix factorizations call functions from SuiteSparse. Other sparse solvers are available as Julia packages.

Base.:* — Method

1. *(A::AbstractMatrix, B::AbstractMatrix)

Matrix multiplication.

Examples

1. julia> [1 1; 0 1] * [1 0; 1 1]
2. 2×2 Matrix{Int64}:
3. 2  1
4. 1  1

[Base.:](#Base.:\-Tuple{AbstractMatrix, AbstractVecOrMat}) — Method

1. \(A, B)

Matrix division using a polyalgorithm. For input matrices A and B, the result X is such that A*X == B when A is square. The solver that is used depends upon the structure of A. If A is upper or lower triangular (or diagonal), no factorization of A is required and the system is solved with either forward or backward substitution. For non-triangular square matrices, an LU factorization is used.

For rectangular A the result is the minimum-norm least squares solution computed by a pivoted QR factorization of A and a rank estimate of A based on the R factor.

When A is sparse, a similar polyalgorithm is used. For indefinite matrices, the LDLt factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.

See also: factorize, pinv.

Examples

1. julia> A = [1 0; 1 -2]; B = [32; -4];

3. julia> X = A \ B
4. 2-element Vector{Float64}:
5. 32.0
6. 18.0

8. julia> A * X == B
9. true

LinearAlgebra.SingularException — Type

1. SingularException

Exception thrown when the input matrix has one or more zero-valued eigenvalues, and is not invertible. A linear solve involving such a matrix cannot be computed. The info field indicates the location of (one of) the singular value(s).

LinearAlgebra.PosDefException — Type

1. PosDefException

Exception thrown when the input matrix was not positive definite. Some linear algebra functions and factorizations are only applicable to positive definite matrices. The info field indicates the location of (one of) the eigenvalue(s) which is (are) less than/equal to 0.

LinearAlgebra.ZeroPivotException — Type

1. ZeroPivotException <: Exception

Exception thrown when a matrix factorization/solve encounters a zero in a pivot (diagonal) position and cannot proceed. This may not mean that the matrix is singular: it may be fruitful to switch to a diffent factorization such as pivoted LU that can re-order variables to eliminate spurious zero pivots. The info field indicates the location of (one of) the zero pivot(s).

LinearAlgebra.dot — Function

1. dot(x, y)
2. x ⋅ y

Compute the dot product between two vectors. For complex vectors, the first vector is conjugated.

dot also works on arbitrary iterable objects, including arrays of any dimension, as long as dot is defined on the elements.

dot is semantically equivalent to sum(dot(vx,vy) for (vx,vy) in zip(x, y)), with the added restriction that the arguments must have equal lengths.

x ⋅ y (where ⋅ can be typed by tab-completing \cdot in the REPL) is a synonym for dot(x, y).

Examples

1. julia> dot([1; 1], [2; 3])
2. 5

4. julia> dot([im; im], [1; 1])
5. 0 - 2im

7. julia> dot(1:5, 2:6)
8. 70

10. julia> x = fill(2., (5,5));

12. julia> y = fill(3., (5,5));

14. julia> dot(x, y)
15. 150.0

LinearAlgebra.dot — Method

1. dot(x, A, y)

Compute the generalized dot product dot(x, A*y) between two vectors x and y, without storing the intermediate result of A*y. As for the two-argument dot(_,_), this acts recursively. Moreover, for complex vectors, the first vector is conjugated.

Julia 1.4

Three-argument dot requires at least Julia 1.4.

Examples

1. julia> dot([1; 1], [1 2; 3 4], [2; 3])
2. 26

4. julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
5. 4850

7. julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
8. true

LinearAlgebra.cross — Function

1. cross(x, y)
2. ×(x,y)

Compute the cross product of two 3-vectors.

Examples

1. julia> a = [0;1;0]
2. 3-element Vector{Int64}:
3. 0
4. 1
5. 0

7. julia> b = [0;0;1]
8. 3-element Vector{Int64}:
9. 0
10. 0
11. 1

13. julia> cross(a,b)
14. 3-element Vector{Int64}:
15. 1
16. 0
17. 0

LinearAlgebra.factorize — Function

1. factorize(A)

Compute a convenient factorization of A, based upon the type of the input matrix. factorize checks A to see if it is symmetric/triangular/etc. if A is passed as a generic matrix. factorize checks every element of A to verify/rule out each property. It will short-circuit as soon as it can rule out symmetry/triangular structure. The return value can be reused for efficient solving of multiple systems. For example: A=factorize(A); x=A\b; y=A\C.

If factorize is called on a Hermitian positive-definite matrix, for instance, then factorize will return a Cholesky factorization.

Examples

1. julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
2. 5×5 Matrix{Float64}:
3. 1.0  1.0  0.0  0.0  0.0
4. 0.0  1.0  1.0  0.0  0.0
5. 0.0  0.0  1.0  1.0  0.0
6. 0.0  0.0  0.0  1.0  1.0
7. 0.0  0.0  0.0  0.0  1.0

9. julia> factorize(A) # factorize will check to see that A is already factorized
10. 5×5 Bidiagonal{Float64, Vector{Float64}}:
11. 1.0  1.0   ⋅    ⋅    ⋅
12. ⋅   1.0  1.0   ⋅    ⋅
13. ⋅    ⋅   1.0  1.0   ⋅
14. ⋅    ⋅    ⋅   1.0  1.0
15. ⋅    ⋅    ⋅    ⋅   1.0

This returns a 5×5 Bidiagonal{Float64}, which can now be passed to other linear algebra functions (e.g. eigensolvers) which will use specialized methods for Bidiagonal types.

LinearAlgebra.Diagonal — Type

1. Diagonal(V::AbstractVector)

Construct a matrix with V as its diagonal.

See also diag, diagm.

Examples

1. julia> Diagonal([1, 10, 100])
2. 3×3 Diagonal{Int64, Vector{Int64}}:
3. 1   ⋅    ⋅
4. ⋅  10    ⋅
5. ⋅   ⋅  100

7. julia> diagm([7, 13])
8. 2×2 Matrix{Int64}:
9. 7   0
10. 0  13

1. Diagonal(A::AbstractMatrix)

Construct a matrix from the diagonal of A.

Examples

1. julia> A = permutedims(reshape(1:15, 5, 3))
2. 3×5 Matrix{Int64}:
3. 1   2   3   4   5
4. 6   7   8   9  10
5. 11  12  13  14  15

7. julia> Diagonal(A)
8. 3×3 Diagonal{Int64, Vector{Int64}}:
9. 1  ⋅   ⋅
10. ⋅  7   ⋅
11. ⋅  ⋅  13

13. julia> diag(A, 2)
14. 3-element Vector{Int64}:
15. 3
16. 9
17. 15

1. Diagonal{T}(undef, n)

Construct an uninitialized Diagonal{T} of length n. See undef.

LinearAlgebra.Bidiagonal — Type

1. Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector

Constructs an upper (uplo=:U) or lower (uplo=:L) bidiagonal matrix using the given diagonal (dv) and off-diagonal (ev) vectors. The result is of type Bidiagonal and provides efficient specialized linear solvers, but may be converted into a regular matrix with convert(Array, _) (or Array(_) for short). The length of ev must be one less than the length of dv.

Examples

1. julia> dv = [1, 2, 3, 4]
2. 4-element Vector{Int64}:
3. 1
4. 2
5. 3
6. 4

8. julia> ev = [7, 8, 9]
9. 3-element Vector{Int64}:
10. 7
11. 8
12. 9

14. julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
15. 4×4 Bidiagonal{Int64, Vector{Int64}}:
16. 1  7  ⋅  ⋅
17. ⋅  2  8  ⋅
18. ⋅  ⋅  3  9
19. ⋅  ⋅  ⋅  4

21. julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
22. 4×4 Bidiagonal{Int64, Vector{Int64}}:
23. 1  ⋅  ⋅  ⋅
24. 7  2  ⋅  ⋅
25. ⋅  8  3  ⋅
26. ⋅  ⋅  9  4

1. Bidiagonal(A, uplo::Symbol)

Construct a Bidiagonal matrix from the main diagonal of A and its first super- (if uplo=:U) or sub-diagonal (if uplo=:L).

Examples

1. julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
2. 4×4 Matrix{Int64}:
3. 1  1  1  1
4. 2  2  2  2
5. 3  3  3  3
6. 4  4  4  4

8. julia> Bidiagonal(A, :U) # contains the main diagonal and first superdiagonal of A
9. 4×4 Bidiagonal{Int64, Vector{Int64}}:
10. 1  1  ⋅  ⋅
11. ⋅  2  2  ⋅
12. ⋅  ⋅  3  3
13. ⋅  ⋅  ⋅  4

15. julia> Bidiagonal(A, :L) # contains the main diagonal and first subdiagonal of A
16. 4×4 Bidiagonal{Int64, Vector{Int64}}:
17. 1  ⋅  ⋅  ⋅
18. 2  2  ⋅  ⋅
19. ⋅  3  3  ⋅
20. ⋅  ⋅  4  4

LinearAlgebra.SymTridiagonal — Type

1. SymTridiagonal(dv::V, ev::V) where V <: AbstractVector

Construct a symmetric tridiagonal matrix from the diagonal (dv) and first sub/super-diagonal (ev), respectively. The result is of type SymTridiagonal and provides efficient specialized eigensolvers, but may be converted into a regular matrix with convert(Array, _) (or Array(_) for short).

For SymTridiagonal block matrices, the elements of dv are symmetrized. The argument ev is interpreted as the superdiagonal. Blocks from the subdiagonal are (materialized) transpose of the corresponding superdiagonal blocks.

Examples

1. julia> dv = [1, 2, 3, 4]
2. 4-element Vector{Int64}:
3. 1
4. 2
5. 3
6. 4

8. julia> ev = [7, 8, 9]
9. 3-element Vector{Int64}:
10. 7
11. 8
12. 9

14. julia> SymTridiagonal(dv, ev)
15. 4×4 SymTridiagonal{Int64, Vector{Int64}}:
16. 1  7  ⋅  ⋅
17. 7  2  8  ⋅
18. ⋅  8  3  9
19. ⋅  ⋅  9  4

21. julia> A = SymTridiagonal(fill([1 2; 3 4], 3), fill([1 2; 3 4], 2));

23. julia> A[1,1]
24. 2×2 Symmetric{Int64, Matrix{Int64}}:
25. 1  2
26. 2  4

28. julia> A[1,2]
29. 2×2 Matrix{Int64}:
30. 1  2
31. 3  4

33. julia> A[2,1]
34. 2×2 Matrix{Int64}:
35. 1  3
36. 2  4

1. SymTridiagonal(A::AbstractMatrix)

Construct a symmetric tridiagonal matrix from the diagonal and first superdiagonal of the symmetric matrix A.

Examples

1. julia> A = [1 2 3; 2 4 5; 3 5 6]
2. 3×3 Matrix{Int64}:
3. 1  2  3
4. 2  4  5
5. 3  5  6

7. julia> SymTridiagonal(A)
8. 3×3 SymTridiagonal{Int64, Vector{Int64}}:
9. 1  2  ⋅
10. 2  4  5
11. ⋅  5  6

13. julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

15. julia> SymTridiagonal(B)
16. 2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
17. [1 2; 2 3]  [1 3; 2 4]
18. [1 2; 3 4]  [1 2; 2 3]

LinearAlgebra.Tridiagonal — Type

1. Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

Construct a tridiagonal matrix from the first subdiagonal, diagonal, and first superdiagonal, respectively. The result is of type Tridiagonal and provides efficient specialized linear solvers, but may be converted into a regular matrix with convert(Array, _) (or Array(_) for short). The lengths of dl and du must be one less than the length of d.

Examples

1. julia> dl = [1, 2, 3];

3. julia> du = [4, 5, 6];

5. julia> d = [7, 8, 9, 0];

7. julia> Tridiagonal(dl, d, du)
8. 4×4 Tridiagonal{Int64, Vector{Int64}}:
9. 7  4  ⋅  ⋅
10. 1  8  5  ⋅
11. ⋅  2  9  6
12. ⋅  ⋅  3  0

1. Tridiagonal(A)

Construct a tridiagonal matrix from the first sub-diagonal, diagonal and first super-diagonal of the matrix A.

Examples

1. julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
2. 4×4 Matrix{Int64}:
3. 1  2  3  4
4. 1  2  3  4
5. 1  2  3  4
6. 1  2  3  4

8. julia> Tridiagonal(A)
9. 4×4 Tridiagonal{Int64, Vector{Int64}}:
10. 1  2  ⋅  ⋅
11. 1  2  3  ⋅
12. ⋅  2  3  4
13. ⋅  ⋅  3  4

LinearAlgebra.Symmetric — Type

1. Symmetric(A, uplo=:U)

Construct a Symmetric view of the upper (if uplo = :U) or lower (if uplo = :L) triangle of the matrix A.

Examples

1. julia> A = [1 0 2 0 3; 0 4 0 5 0; 6 0 7 0 8; 0 9 0 1 0; 2 0 3 0 4]
2. 5×5 Matrix{Int64}:
3. 1  0  2  0  3
4. 0  4  0  5  0
5. 6  0  7  0  8
6. 0  9  0  1  0
7. 2  0  3  0  4

9. julia> Supper = Symmetric(A)
10. 5×5 Symmetric{Int64, Matrix{Int64}}:
11. 1  0  2  0  3
12. 0  4  0  5  0
13. 2  0  7  0  8
14. 0  5  0  1  0
15. 3  0  8  0  4

17. julia> Slower = Symmetric(A, :L)
18. 5×5 Symmetric{Int64, Matrix{Int64}}:
19. 1  0  6  0  2
20. 0  4  0  9  0
21. 6  0  7  0  3
22. 0  9  0  1  0
23. 2  0  3  0  4

Note that Supper will not be equal to Slower unless A is itself symmetric (e.g. if A == transpose(A)).

LinearAlgebra.Hermitian — Type

1. Hermitian(A, uplo=:U)

Construct a Hermitian view of the upper (if uplo = :U) or lower (if uplo = :L) triangle of the matrix A.

Examples

1. julia> A = [1 0 2+2im 0 3-3im; 0 4 0 5 0; 6-6im 0 7 0 8+8im; 0 9 0 1 0; 2+2im 0 3-3im 0 4];

3. julia> Hupper = Hermitian(A)
4. 5×5 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
5. 1+0im  0+0im  2+2im  0+0im  3-3im
6. 0+0im  4+0im  0+0im  5+0im  0+0im
7. 2-2im  0+0im  7+0im  0+0im  8+8im
8. 0+0im  5+0im  0+0im  1+0im  0+0im
9. 3+3im  0+0im  8-8im  0+0im  4+0im

11. julia> Hlower = Hermitian(A, :L)
12. 5×5 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
13. 1+0im  0+0im  6+6im  0+0im  2-2im
14. 0+0im  4+0im  0+0im  9+0im  0+0im
15. 6-6im  0+0im  7+0im  0+0im  3+3im
16. 0+0im  9+0im  0+0im  1+0im  0+0im
17. 2+2im  0+0im  3-3im  0+0im  4+0im

Note that Hupper will not be equal to Hlower unless A is itself Hermitian (e.g. if A == adjoint(A)).

All non-real parts of the diagonal will be ignored.

1. Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)

LinearAlgebra.LowerTriangular — Type

1. LowerTriangular(A::AbstractMatrix)

Construct a LowerTriangular view of the matrix A.

Examples

1. julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
2. 3×3 Matrix{Float64}:
3. 1.0  2.0  3.0
4. 4.0  5.0  6.0
5. 7.0  8.0  9.0

7. julia> LowerTriangular(A)
8. 3×3 LowerTriangular{Float64, Matrix{Float64}}:
9. 1.0   ⋅    ⋅
10. 4.0  5.0   ⋅
11. 7.0  8.0  9.0

LinearAlgebra.UpperTriangular — Type

1. UpperTriangular(A::AbstractMatrix)

Construct an UpperTriangular view of the matrix A.

Examples

1. julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
2. 3×3 Matrix{Float64}:
3. 1.0  2.0  3.0
4. 4.0  5.0  6.0
5. 7.0  8.0  9.0

7. julia> UpperTriangular(A)
8. 3×3 UpperTriangular{Float64, Matrix{Float64}}:
9. 1.0  2.0  3.0
10. ⋅   5.0  6.0
11. ⋅    ⋅   9.0

LinearAlgebra.UnitLowerTriangular — Type

1. UnitLowerTriangular(A::AbstractMatrix)

Construct a UnitLowerTriangular view of the matrix A. Such a view has the oneunit of the eltype of A on its diagonal.

Examples

1. julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
2. 3×3 Matrix{Float64}:
3. 1.0  2.0  3.0
4. 4.0  5.0  6.0
5. 7.0  8.0  9.0

7. julia> UnitLowerTriangular(A)
8. 3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
9. 1.0   ⋅    ⋅
10. 4.0  1.0   ⋅
11. 7.0  8.0  1.0

LinearAlgebra.UnitUpperTriangular — Type

1. UnitUpperTriangular(A::AbstractMatrix)

Construct an UnitUpperTriangular view of the matrix A. Such a view has the oneunit of the eltype of A on its diagonal.

Examples

1. julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
2. 3×3 Matrix{Float64}:
3. 1.0  2.0  3.0
4. 4.0  5.0  6.0
5. 7.0  8.0  9.0

7. julia> UnitUpperTriangular(A)
8. 3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
9. 1.0  2.0  3.0
10. ⋅   1.0  6.0
11. ⋅    ⋅   1.0

LinearAlgebra.UpperHessenberg — Type

1. UpperHessenberg(A::AbstractMatrix)

Construct an UpperHessenberg view of the matrix A. Entries of A below the first subdiagonal are ignored.

Efficient algorithms are implemented for H \ b, det(H), and similar.

See also the hessenberg function to factor any matrix into a similar upper-Hessenberg matrix.

If F::Hessenberg is the factorization object, the unitary matrix can be accessed with F.Q and the Hessenberg matrix with F.H. When Q is extracted, the resulting type is the HessenbergQ object, and may be converted to a regular matrix with convert(Array, _) (or Array(_) for short).

Iterating the decomposition produces the factors F.Q and F.H.

Examples

1. julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
2. 4×4 Matrix{Int64}:
3. 1   2   3   4
4. 5   6   7   8
5. 9  10  11  12
6. 13  14  15  16

8. julia> UpperHessenberg(A)
9. 4×4 UpperHessenberg{Int64, Matrix{Int64}}:
10. 1   2   3   4
11. 5   6   7   8
12. ⋅  10  11  12
13. ⋅   ⋅  15  16

LinearAlgebra.UniformScaling — Type

1. UniformScaling{T<:Number}

Generically sized uniform scaling operator defined as a scalar times the identity operator, λ*I. Although without an explicit size, it acts similarly to a matrix in many cases and includes support for some indexing. See also I.

Julia 1.6

Indexing using ranges is available as of Julia 1.6.

Examples

1. julia> J = UniformScaling(2.)
2. UniformScaling{Float64}
3. 2.0*I

5. julia> A = [1. 2.; 3. 4.]
6. 2×2 Matrix{Float64}:
7. 1.0  2.0
8. 3.0  4.0

10. julia> J*A
11. 2×2 Matrix{Float64}:
12. 2.0  4.0
13. 6.0  8.0

15. julia> J[1:2, 1:2]
16. 2×2 Matrix{Float64}:
17. 2.0  0.0
18. 0.0  2.0

LinearAlgebra.I — Constant

1. I

An object of type UniformScaling, representing an identity matrix of any size.

Examples

1. julia> fill(1, (5,6)) * I == fill(1, (5,6))
2. true

4. julia> [1 2im 3; 1im 2 3] * I
5. 2×3 Matrix{Complex{Int64}}:
6. 1+0im  0+2im  3+0im
7. 0+1im  2+0im  3+0im

LinearAlgebra.UniformScaling — Method

1. (I::UniformScaling)(n::Integer)

Construct a Diagonal matrix from a UniformScaling.

Julia 1.2

This method is available as of Julia 1.2.

Examples

1. julia> I(3)
2. 3×3 Diagonal{Bool, Vector{Bool}}:
3. 1  ⋅  ⋅
4. ⋅  1  ⋅
5. ⋅  ⋅  1

7. julia> (0.7*I)(3)
8. 3×3 Diagonal{Float64, Vector{Float64}}:
9. 0.7   ⋅    ⋅
10. ⋅   0.7   ⋅
11. ⋅    ⋅   0.7

LinearAlgebra.Factorization — Type

1. LinearAlgebra.Factorization

Abstract type for matrix factorizations a.k.a. matrix decompositions. See online documentation for a list of available matrix factorizations.

LinearAlgebra.LU — Type

1. LU <: Factorization

Matrix factorization type of the LU factorization of a square matrix A. This is the return type of lu, the corresponding matrix factorization function.

The individual components of the factorization F::LU can be accessed via getproperty:

Iterating the factorization produces the components F.L, F.U, and F.p.

Examples

1. julia> A = [4 3; 6 3]
2. 2×2 Matrix{Int64}:
3. 4  3
4. 6  3

6. julia> F = lu(A)
7. LU{Float64, Matrix{Float64}}
8. L factor:
9. 2×2 Matrix{Float64}:
10. 1.0       0.0
11. 0.666667  1.0
12. U factor:
13. 2×2 Matrix{Float64}:
14. 6.0  3.0
15. 0.0  1.0

17. julia> F.L * F.U == A[F.p, :]
18. true

20. julia> l, u, p = lu(A); # destructuring via iteration

22. julia> l == F.L && u == F.U && p == F.p
23. true

LinearAlgebra.lu — Function

1. lu(A, pivot = RowMaximum(); check = true) -> F::LU

Compute the LU factorization of A.

When check = true, an error is thrown if the decomposition fails. When check = false, responsibility for checking the decomposition’s validity (via issuccess) lies with the user.

In most cases, if A is a subtype S of AbstractMatrix{T} with an element type T supporting +, -, * and /, the return type is LU{T,S{T}}. If pivoting is chosen (default) the element type should also support abs and <. Pivoting can be turned off by passing pivot = NoPivot().

The individual components of the factorization F can be accessed via getproperty:

Iterating the factorization produces the components F.L, F.U, and F.p.

The relationship between F and A is

F.L*F.U == A[F.p, :]

F further supports the following functions:

Examples

1. julia> A = [4 3; 6 3]
2. 2×2 Matrix{Int64}:
3. 4  3
4. 6  3

6. julia> F = lu(A)
7. LU{Float64, Matrix{Float64}}
8. L factor:
9. 2×2 Matrix{Float64}:
10. 1.0       0.0
11. 0.666667  1.0
12. U factor:
13. 2×2 Matrix{Float64}:
14. 6.0  3.0
15. 0.0  1.0

17. julia> F.L * F.U == A[F.p, :]
18. true

20. julia> l, u, p = lu(A); # destructuring via iteration

22. julia> l == F.L && u == F.U && p == F.p
23. true

LinearAlgebra.lu! — Function

1. lu!(A, pivot = RowMaximum(); check = true) -> LU

lu! is the same as lu, but saves space by overwriting the input A, instead of creating a copy. An InexactError exception is thrown if the factorization produces a number not representable by the element type of A, e.g. for integer types.

Examples

1. julia> A = [4. 3.; 6. 3.]
2. 2×2 Matrix{Float64}:
3. 4.0  3.0
4. 6.0  3.0

6. julia> F = lu!(A)
7. LU{Float64, Matrix{Float64}}
8. L factor:
9. 2×2 Matrix{Float64}:
10. 1.0       0.0
11. 0.666667  1.0
12. U factor:
13. 2×2 Matrix{Float64}:
14. 6.0  3.0
15. 0.0  1.0

17. julia> iA = [4 3; 6 3]
18. 2×2 Matrix{Int64}:
19. 4  3
20. 6  3

22. julia> lu!(iA)
23. ERROR: InexactError: Int64(0.6666666666666666)
24. Stacktrace:
25. [...]

LinearAlgebra.Cholesky — Type

1. Cholesky <: Factorization

Matrix factorization type of the Cholesky factorization of a dense symmetric/Hermitian positive definite matrix A. This is the return type of cholesky, the corresponding matrix factorization function.

The triangular Cholesky factor can be obtained from the factorization F::Cholesky via F.L and F.U, where A ≈ F.U' * F.U ≈ F.L * F.L'.

The following functions are available for Cholesky objects: size, [](/read/Julia-1.7-zh/b03d1d5dc0f200e1.md#Base.:\-Tuple{Any, Any}), inv, det, logdet and isposdef.

Iterating the decomposition produces the components L and U.

Examples

1. julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
2. 3×3 Matrix{Float64}:
3. 4.0   12.0  -16.0
4. 12.0   37.0  -43.0
5. -16.0  -43.0   98.0

7. julia> C = cholesky(A)
8. Cholesky{Float64, Matrix{Float64}}
9. U factor:
10. 3×3 UpperTriangular{Float64, Matrix{Float64}}:
11. 2.0  6.0  -8.0
12. ⋅   1.0   5.0
13. ⋅    ⋅    3.0

15. julia> C.U
16. 3×3 UpperTriangular{Float64, Matrix{Float64}}:
17. 2.0  6.0  -8.0
18. ⋅   1.0   5.0
19. ⋅    ⋅    3.0

21. julia> C.L
22. 3×3 LowerTriangular{Float64, Matrix{Float64}}:
23. 2.0   ⋅    ⋅
24. 6.0  1.0   ⋅
25. -8.0  5.0  3.0

27. julia> C.L * C.U == A
28. true

30. julia> l, u = C; # destructuring via iteration

32. julia> l == C.L && u == C.U
33. true

LinearAlgebra.CholeskyPivoted — Type

1. CholeskyPivoted

Matrix factorization type of the pivoted Cholesky factorization of a dense symmetric/Hermitian positive semi-definite matrix A. This is the return type of cholesky(_, Val(true)), the corresponding matrix factorization function.

The triangular Cholesky factor can be obtained from the factorization F::CholeskyPivoted via F.L and F.U, and the permutation via F.p, where A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' with Ur = F.U[1:F.rank, :] and Lr = F.L[:, 1:F.rank], or alternatively A ≈ Up' * Up ≈ Lp * Lp' with Up = F.U[1:F.rank, invperm(F.p)] and Lp = F.L[invperm(F.p), 1:F.rank].

The following functions are available for CholeskyPivoted objects: size, [](/read/Julia-1.7-zh/b03d1d5dc0f200e1.md#Base.:\-Tuple{Any, Any}), inv, det, and rank.

Iterating the decomposition produces the components L and U.

Examples

1. julia> X = [1.0, 2.0, 3.0, 4.0];

3. julia> A = X * X';

5. julia> C = cholesky(A, Val(true), check = false)
6. CholeskyPivoted{Float64, Matrix{Float64}}
7. U factor with rank 1:
8. 4×4 UpperTriangular{Float64, Matrix{Float64}}:
9. 4.0  2.0  3.0  1.0
10. ⋅   0.0  6.0  2.0
11. ⋅    ⋅   9.0  3.0
12. ⋅    ⋅    ⋅   1.0
13. permutation:
14. 4-element Vector{Int64}:
15. 4
16. 2
17. 3
18. 1

20. julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
21. true

23. julia> l, u = C; # destructuring via iteration

25. julia> l == C.L && u == C.U
26. true

LinearAlgebra.cholesky — Function

1. cholesky(A, Val(false); check = true) -> Cholesky

Compute the Cholesky factorization of a dense symmetric positive definite matrix A and return a Cholesky factorization. The matrix A can either be a Symmetric or Hermitian StridedMatrix or a perfectly symmetric or Hermitian StridedMatrix.

The triangular Cholesky factor can be obtained from the factorization F via F.L and F.U, where A ≈ F.U' * F.U ≈ F.L * F.L'.

The following functions are available for Cholesky objects: size, [](/read/Julia-1.7-zh/b03d1d5dc0f200e1.md#Base.:\-Tuple{Any, Any}), inv, det, logdet and isposdef.

If you have a matrix A that is slightly non-Hermitian due to roundoff errors in its construction, wrap it in Hermitian(A) before passing it to cholesky in order to treat it as perfectly Hermitian.

When check = true, an error is thrown if the decomposition fails. When check = false, responsibility for checking the decomposition’s validity (via issuccess) lies with the user.

Examples

1. julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
2. 3×3 Matrix{Float64}:
3. 4.0   12.0  -16.0
4. 12.0   37.0  -43.0
5. -16.0  -43.0   98.0

7. julia> C = cholesky(A)
8. Cholesky{Float64, Matrix{Float64}}
9. U factor:
10. 3×3 UpperTriangular{Float64, Matrix{Float64}}:
11. 2.0  6.0  -8.0
12. ⋅   1.0   5.0
13. ⋅    ⋅    3.0

15. julia> C.U
16. 3×3 UpperTriangular{Float64, Matrix{Float64}}:
17. 2.0  6.0  -8.0
18. ⋅   1.0   5.0
19. ⋅    ⋅    3.0

21. julia> C.L
22. 3×3 LowerTriangular{Float64, Matrix{Float64}}:
23. 2.0   ⋅    ⋅
24. 6.0  1.0   ⋅
25. -8.0  5.0  3.0

27. julia> C.L * C.U == A
28. true

1. cholesky(A, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

Compute the pivoted Cholesky factorization of a dense symmetric positive semi-definite matrix A and return a CholeskyPivoted factorization. The matrix A can either be a Symmetric or Hermitian StridedMatrix or a perfectly symmetric or Hermitian StridedMatrix.

The triangular Cholesky factor can be obtained from the factorization F via F.L and F.U, and the permutation via F.p, where A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' with Ur = F.U[1:F.rank, :] and Lr = F.L[:, 1:F.rank], or alternatively A ≈ Up' * Up ≈ Lp * Lp' with Up = F.U[1:F.rank, invperm(F.p)] and Lp = F.L[invperm(F.p), 1:F.rank].

The following functions are available for CholeskyPivoted objects: size, [](/read/Julia-1.7-zh/b03d1d5dc0f200e1.md#Base.:\-Tuple{Any, Any}), inv, det, and rank.

The argument tol determines the tolerance for determining the rank. For negative values, the tolerance is the machine precision.

If you have a matrix A that is slightly non-Hermitian due to roundoff errors in its construction, wrap it in Hermitian(A) before passing it to cholesky in order to treat it as perfectly Hermitian.

When check = true, an error is thrown if the decomposition fails. When check = false, responsibility for checking the decomposition’s validity (via issuccess) lies with the user.

Examples

1. julia> X = [1.0, 2.0, 3.0, 4.0];

3. julia> A = X * X';

5. julia> C = cholesky(A, Val(true), check = false)
6. CholeskyPivoted{Float64, Matrix{Float64}}
7. U factor with rank 1:
8. 4×4 UpperTriangular{Float64, Matrix{Float64}}:
9. 4.0  2.0  3.0  1.0
10. ⋅   0.0  6.0  2.0
11. ⋅    ⋅   9.0  3.0
12. ⋅    ⋅    ⋅   1.0
13. permutation:
14. 4-element Vector{Int64}:
15. 4
16. 2
17. 3
18. 1

20. julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
21. true

23. julia> l, u = C; # destructuring via iteration

25. julia> l == C.L && u == C.U
26. true

LinearAlgebra.cholesky! — Function

1. cholesky!(A::StridedMatrix, Val(false); check = true) -> Cholesky

The same as cholesky, but saves space by overwriting the input A, instead of creating a copy. An InexactError exception is thrown if the factorization produces a number not representable by the element type of A, e.g. for integer types.

Examples

1. julia> A = [1 2; 2 50]
2. 2×2 Matrix{Int64}:
3. 1   2
4. 2  50

6. julia> cholesky!(A)
7. ERROR: InexactError: Int64(6.782329983125268)
8. Stacktrace:
9. [...]

1. cholesky!(A::StridedMatrix, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

The same as cholesky, but saves space by overwriting the input A, instead of creating a copy. An InexactError exception is thrown if the factorization produces a number not representable by the element type of A, e.g. for integer types.

LinearAlgebra.lowrankupdate — Function

1. lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Update a Cholesky factorization C with the vector v. If A = C.U'C.U then CC = cholesky(C.U'C.U + v*v') but the compu

（本文超出站点单文档体积上限，已截断）