Linear Algebra

In addition to (and as part of) its support for multi-dimensional arrays, Julia provides native implementations of many common and useful linear algebra operations which can be loaded with using LinearAlgebra. Basic operations, such as tr, det, and inv are all supported:

1. julia> A = [1 2 3; 4 1 6; 7 8 1]
2. 3×3 Array{Int64,2}:
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 Array{Float64,2}:
15. -0.451923   0.211538    0.0865385
16. 0.365385  -0.192308    0.0576923
17. 0.240385   0.0576923  -0.0673077

As well as other useful operations, such as finding eigenvalues or eigenvectors:

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

6. julia> eigvals(A)
7. 2-element Array{Complex{Float64},1}:
8. -1.0 + 5.0im
9. -1.0 - 5.0im

11. julia> eigvecs(A)
12. 2×2 Array{Complex{Float64},2}:
13. 0.945905+0.0im        0.945905-0.0im
14. -0.166924-0.278207im  -0.166924+0.278207im

In addition, Julia provides many factorizations which can be used to speed up problems such as linear solve or matrix exponentiation by pre-factorizing a matrix into a form more amenable (for performance or memory reasons) to the problem. See the documentation on factorize for more information. As an example:

1. julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
2. 3×3 Array{Float64,2}:
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,Array{Float64,2}}
9. L factor:
10. 3×3 Array{Float64,2}:
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 Array{Float64,2}:
16. -10.0  2.3     4.0
17. 0.0  2.345  -3.4
18. 0.0  0.0    -5.24947

Since A is not Hermitian, symmetric, triangular, tridiagonal, or bidiagonal, an LU factorization may be the best we can do. Compare with:

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Array{Float64,2}:
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,Array{Float64,2}}
9. D factor:
10. 3×3 Tridiagonal{Float64,Array{Float64,1}}:
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,Array{Float64,2}}:
16. 1.0  0.142857  -0.8
17. ⋅   1.0       -0.6
18. ⋅    ⋅         1.0
19. permutation:
20. 3-element Array{Int64,1}:
21. 1
22. 2
23. 3

Here, Julia was able to detect that B is in fact symmetric, and used a more appropriate factorization. Often it’s possible to write more efficient code for a matrix that is known to have certain properties e.g. it is symmetric, or tridiagonal. Julia provides some special types so that you can “tag” matrices as having these properties. For instance:

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Array{Float64,2}:
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,Array{Float64,2}}:
9. 1.5   2.0  -4.0
10. 2.0  -1.0  -3.0
11. -4.0  -3.0   5.0

sB has been tagged as a matrix that’s (real) symmetric, so for later operations we might perform on it, such as eigenfactorization or computing matrix-vector products, efficiencies can be found by only referencing half of it. For example:

1. julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
2. 3×3 Array{Float64,2}:
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,Array{Float64,2}}:
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 Array{Int64,1}:
15. 1
16. 2
17. 3

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

The \ operation here performs the linear solution. The left-division operator is pretty powerful and it’s easy to write compact, readable code that is flexible enough to solve all sorts of systems of linear equations.

Special matrices

Matrices with special symmetries and structures arise often in linear algebra and are frequently associated with various matrix factorizations. Julia features a rich collection of special matrix types, which allow for fast computation with specialized routines that are specially developed for particular matrix types.

The following tables summarize the types of special matrices that have been implemented in Julia, as well as whether hooks to various optimized methods for them in LAPACK are available.

Elementary operations

Legend:

Matrix factorizations

Legend:

The uniform scaling operator

A UniformScaling operator represents a scalar times the identity operator, λ*I. The identity operator I is defined as a constant and is an instance of UniformScaling. The size of these operators are generic and match the other matrix in the binary operations +, -, * and \. For A+I and A-I this means that A must be square. Multiplication with the identity operator I is a noop (except for checking that the scaling factor is one) and therefore almost without overhead.

To see the UniformScaling operator in action:

1. julia> U = UniformScaling(2);

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

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

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

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

23. julia> b = [1 2 3; 4 5 6]
24. 2×3 Array{Int64,2}:
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. [...]

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 factorizations call functions from SuiteSparse.

Base.:* — Method.

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

Matrix multiplication.

Examples

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

source

Base.:\ — 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.

Examples

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

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

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

source

LinearAlgebra.dot — Function.

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

For any iterable containers x and y (including arrays of any dimension) of numbers (or any element type for which dot is defined), compute the dot product (or inner product or scalar product), i.e. the sum of dot(x[i],y[i]), as if they were vectors.

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:5, 2:6)
2. 70

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

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

8. julia> dot(x, y)
9. 150.0

source

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

Compute the dot product between two vectors. For complex vectors, the first vector is conjugated. When the vectors have equal lengths, calling dot is semantically equivalent to sum(dot(vx,vy) for (vx,vy) in zip(x, y)).

Examples

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

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

source

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 Array{Int64,1}:
3. 0
4. 1
5. 0

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

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

source

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 Array{Float64,2}:
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,Array{Float64,1}}:
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.

source

LinearAlgebra.Diagonal — Type.

1. Diagonal(A::AbstractMatrix)

Construct a matrix from the diagonal of A.

Examples

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

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

source

1. Diagonal(V::AbstractVector)

Construct a matrix with V as its diagonal.

Examples

1. julia> V = [1, 2]
2. 2-element Array{Int64,1}:
3. 1
4. 2

6. julia> Diagonal(V)
7. 2×2 Diagonal{Int64,Array{Int64,1}}:
8. 1  ⋅
9. ⋅  2

source

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 Array{Int64,1}:
3. 1
4. 2
5. 3
6. 4

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

14. julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
15. 4×4 Bidiagonal{Int64,Array{Int64,1}}:
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,Array{Int64,1}}:
23. 1  ⋅  ⋅  ⋅
24. 7  2  ⋅  ⋅
25. ⋅  8  3  ⋅
26. ⋅  ⋅  9  4

source

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 Array{Int64,2}:
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,Array{Int64,1}}:
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,Array{Int64,1}}:
17. 1  ⋅  ⋅  ⋅
18. 2  2  ⋅  ⋅
19. ⋅  3  3  ⋅
20. ⋅  ⋅  4  4

source

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).

Examples

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

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

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

source

1. SymTridiagonal(A::AbstractMatrix)

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

Examples

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

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

source

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,Array{Int64,1}}:
9. 7  4  ⋅  ⋅
10. 1  8  5  ⋅
11. ⋅  2  9  6
12. ⋅  ⋅  3  0

source

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 Array{Int64,2}:
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,Array{Int64,1}}:
10. 1  2  ⋅  ⋅
11. 1  2  3  ⋅
12. ⋅  2  3  4
13. ⋅  ⋅  3  4

source

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 Array{Int64,2}:
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,Array{Int64,2}}:
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,Array{Int64,2}}:
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)).

source

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},Array{Complex{Int64},2}}:
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},Array{Complex{Int64},2}}:
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)

source

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 Array{Float64,2}:
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,Array{Float64,2}}:
9. 1.0   ⋅    ⋅
10. 4.0  5.0   ⋅
11. 7.0  8.0  9.0

source

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 Array{Float64,2}:
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,Array{Float64,2}}:
9. 1.0  2.0  3.0
10. ⋅   5.0  6.0
11. ⋅    ⋅   9.0

source

LinearAlgebra.UniformScaling — Type.

1. UniformScaling{T<:Number}

Generically sized uniform scaling operator defined as a scalar times the identity operator, λ*I. See also I.

Examples

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

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

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

source

LinearAlgebra.lu — Function.

1. lu(A, pivot=Val(true); 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 <.

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 Array{Int64,2}:
3. 4  3
4. 6  3

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

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

source

LinearAlgebra.lu! — Function.

1. lu!(A, pivot=Val(true); 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 Array{Float64,2}:
3. 4.0  3.0
4. 6.0  3.0

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

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

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

source

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 with: F.L and F.U. The following functions are available for Cholesky objects: size, \, inv, det, logdet and isposdef.

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 Array{Float64,2}:
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,Array{Float64,2}}
9. U factor:
10. 3×3 UpperTriangular{Float64,Array{Float64,2}}:
11. 2.0  6.0  -8.0
12. ⋅   1.0   5.0
13. ⋅    ⋅    3.0

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

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

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

source

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 with: F.L and F.U. The following functions are available for PivotedCholesky objects: size, \, inv, det, and rank. The argument tol determines the tolerance for determining the rank. For negative values, the tolerance is the machine precision.

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.

source

LinearAlgebra.cholesky! — Function.

1. cholesky!(A, 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 Array{Int64,2}:
3. 1   2
4. 2  50

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

source

1. cholesky!(A, 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.

source

LinearAlgebra.lowrankupdate — Function.

1. lowrankupdate(C::Cholesky, v::StridedVector) -> 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 computation of CC only uses O(n^2) operations.

source

LinearAlgebra.lowrankdowndate — Function.

1. lowrankdowndate(C::Cholesky, v::StridedVector) -> CC::Cholesky

Downdate 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 computation of CC only uses O(n^2) operations.

source

LinearAlgebra.lowrankupdate! — Function.

1. lowrankupdate!(C::Cholesky, v::StridedVector) -> 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 computation of CC only uses O(n^2) operations. The input factorization C is updated in place such that on exit C == CC. The vector v is destroyed during the computation.

source

LinearAlgebra.lowrankdowndate! — Function.

1. lowrankdowndate!(C::Cholesky, v::StridedVector) -> CC::Cholesky

Downdate 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 computation of CC only uses O(n^2) operations. The input factorization C is updated in place such that on exit C == CC. The vector v is destroyed during the computation.

source

LinearAlgebra.ldlt — Function.

1. ldlt(S::SymTridiagonal) -> LDLt

Compute an LDLt factorization of the real symmetric tridiagonal matrix S such that S = L*Diagonal(d)*L' where L is a unit lower triangular matrix and d is a vector. The main use of an LDLt factorization F = ldlt(S) is to solve the linear system of equations Sx = b with F\b.

Examples

1. julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
2. 3×3 SymTridiagonal{Float64,Array{Float64,1}}:
3. 3.0  1.0   ⋅
4. 1.0  4.0  2.0
5. ⋅   2.0  5.0

7. julia> ldltS = ldlt(S);

9. julia> b = [6., 7., 8.];

11. julia> ldltS \ b
12. 3-element Array{Float64,1}:
13. 1.7906976744186047
14. 0.627906976744186
15. 1.3488372093023255

17. julia> S \ b
18. 3-element Array{Float64,1}:
19. 1.7906976744186047
20. 0.627906976744186
21. 1.3488372093023255

source

LinearAlgebra.ldlt! — Function.

1. ldlt!(S::SymTridiagonal) -> LDLt

Same as ldlt, but saves space by overwriting the input S, instead of creating a copy.

Examples

1. julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
2. 3×3 SymTridiagonal{Float64,Array{Float64,1}}:
3. 3.0  1.0   ⋅
4. 1.0  4.0  2.0
5. ⋅   2.0  5.0

7. julia> ldltS = ldlt!(S);

9. julia> ldltS === S
10. false

12. julia> S
13. 3×3 SymTridiagonal{Float64,Array{Float64,1}}:
14. 3.0       0.333333   ⋅
15. 0.333333  3.66667   0.545455
16. ⋅        0.545455  3.90909

source

LinearAlgebra.qr — Function.

1. qr(A, pivot=Val(false)) -> F

Compute the QR factorization of the matrix A: an orthogonal (or unitary if A is complex-valued) matrix Q, and an upper triangular matrix R such that

[A = Q R]

The returned object F stores the factorization in a packed format:

• if pivot == Val(true) then F is a QRPivoted object,
• otherwise if the element type of A is a BLAS type (Float32, Float64, ComplexF32 or ComplexF64), then F is a QRCompactWY object,
• otherwise F is a QR object.

The individual components of the decomposition F can be retrieved via property accessors:

• F.Q: the orthogonal/unitary matrix Q
• F.R: the upper triangular matrix R
• F.p: the permutation vector of the pivot (QRPivoted only)
• F.P: the permutation matrix of the pivot (QRPivoted only)

Iterating the decomposition produces the components Q, R, and if extant p.

The following functions are available for the QR objects: inv, size, and \. When A is rectangular, \ will return a least squares solution and if the solution is not unique, the one with smallest norm is returned. When A is not full rank, factorization with (column) pivoting is required to obtain a minimum norm solution.

Multiplication with respect to either full/square or non-full/square Q is allowed, i.e. both F.Q*F.R and F.Q*A are supported. A Q matrix can be converted into a regular matrix with Matrix. This operation returns the “thin” Q factor, i.e., if A is m×n with m>=n, then Matrix(F.Q) yields an m×n matrix with orthonormal columns. To retrieve the “full” Q factor, an m×m orthogonal matrix, use F.Q*Matrix(I,m,m). If m<=n, then Matrix(F.Q) yields an m×m orthogonal matrix.

Examples

1. julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
2. 3×2 Array{Float64,2}:
3. 3.0  -6.0
4. 4.0  -8.0
5. 0.0   1.0

7. julia> F = qr(A)
8. LinearAlgebra.QRCompactWY{Float64,Array{Float64,2}}
9. Q factor:
10. 3×3 LinearAlgebra.QRCompactWYQ{Float64,Array{Float64,2}}:
11. -0.6   0.0   0.8
12. -0.8   0.0  -0.6
13. 0.0  -1.0   0.0
14. R factor:
15. 2×2 Array{Float64,2}:
16. -5.0  10.0
17. 0.0  -1.0

19. julia> F.Q * F.R == A
20. true

Note

qr returns multiple types because LAPACK uses several representations that minimize the memory storage requirements of products of Householder elementary reflectors, so that the Q and R matrices can be stored compactly rather as two separate dense matrices.

source

LinearAlgebra.qr! — Function.

1. qr!(A, pivot=Val(false))

qr! is the same as qr when A is a subtype of StridedMatrix, 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.; 3. 4.]
2. 2×2 Array{Float64,2}:
3. 1.0  2.0
4. 3.0  4.0

6. julia> qr!(a)
7. LinearAlgebra.QRCompactWY{Float64,Array{Float64,2}}
8. Q factor:
9. 2×2 LinearAlgebra.QRCompactWYQ{Float64,Array{Float64,2}}:
10. -0.316228  -0.948683
11. -0.948683   0.316228
12. R factor:
13. 2×2 Array{Float64,2}:
14. -3.16228  -4.42719
15. 0.0      -0.632456

17. julia> a = [1 2; 3 4]
18. 2×2 Array{Int64,2}:
19. 1  2
20. 3  4

22. julia> qr!(a)
23. ERROR: InexactError: Int64(Int64, -3.1622776601683795)
24. Stacktrace:
25. [...]

source

LinearAlgebra.QR — Type.

1. QR <: Factorization

A QR matrix factorization stored in a packed format, typically obtained from qr. If $A$ is an m×n matrix, then

[A = Q R]

where $Q$ is an orthogonal/unitary matrix and $R$ is upper triangular. The matrix $Q$ is stored as a sequence of Householder reflectors $v_i$ and coefficients $\tau_i$ where:

[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).]

Iterating the decomposition produces the components Q and R.

The object has two fields:

• factors is an m×n matrix.

• The upper triangular part contains the elements of $R$, that is R = triu(F.factors) for a QR object F.

• The subdiagonal part contains the reflectors $v_i$ stored in a packed format where $v_i$ is the $i$th column of the matrix `V = I + tril(F.factors,

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