Линейная алгебра

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

Умножение матриц.

Примеры

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

\(A, B)

Деление матриц с использованием полиалгоритма. Для входных матриц A и B, результат X таков, что A*X == B, когда A является квадратной. Решатель, который используется, зависит от структуры A. Если A является верхней или нижней треугольной (или диагональной), факторизация A не требуется, и система решается с помощью прямой или обратной подстановки. Для нетреугольных квадратных матриц используется факторизация LU.

Для прямоугольных A результатом является решение с минимальной нормой наименьших квадратов, вычисленное с помощью факторизации QR с выбором опорных элементов для A и оценки ранга A на основе фактора R.

Когда A является разреженной, используется аналогичный полиалгоритм. Для неопределённых матриц факторизация LDLt не использует выбор опорных элементов во время численных факторизаций, и поэтому процедура может завершиться неудачей даже для обратимых матриц.

См. также: factorize, pinv.

Примеры

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

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

Исключение, выбрасываемое, когда входная матрица имеет одно или несколько нулевых собственных значений и необратима. Линейное решение, включающее такую матрицу, вычислить нельзя. Поле info указывает положение (одного из) сингулярных значений.

PosDefException

Исключение, выбрасываемое, когда входная матрица не является положительно определённой. Некоторые функции линейной алгебры и факторизации применимы только к положительно определённым матрицам. Поле info указывает положение (одного из) собственного значения(й), которое(ые) меньше или равно 0.

ZeroPivotException <: Exception

Исключение, выбрасываемое, когда факторизация/решение матрицы сталкиваются с нулём в позиции опорного элемента (на диагонали) и не могут продолжить вычисления. Это может не означать, что матрица является вырожденной: может быть полезно переключиться на другую факторизацию, например, LU с выбором опорных элементов, которая может переупорядочить переменные для устранения ложных нулевых опорных элементов. Поле info указывает положение (одного из) нулевых опорных элементов.

dot(x, y)
x ⋅ y

Вычисление скалярного произведения двух векторов. Для комплексных векторов первый вектор сопрягается.

dot также работает с произвольными итерируемыми объектами, включая массивы любой размерности, при условии, что dot определено для элементов.

dot семантически эквивалентно sum(dot(vx,vy) for (vx,vy) in zip(x, y)) с дополнительным ограничением, что аргументы должны иметь одинаковую длину.

x ⋅ y (где ⋅ можно ввести, нажав Tab в REPL для \cdot) является синонимом для dot(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

dot(x, A, y)

Вычисление обобщённого скалярного произведения dot(x, A*y) между двумя векторами x и y без хранения промежуточного результата A*y. Как и для двух аргументов dot(_,_), это действие происходит рекурсивно. Кроме того, для комплексных векторов первый вектор сопрягается.

Примеры

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

factorize(A)

Вычисление удобной факторизации A, основанной на типе входной матрицы. factorize проверяет A, чтобы определить, является ли она симметричной/треугольной и т. д., если A передаётся как общая матрица. factorize проверяет каждый элемент A, чтобы проверить/исключить каждое свойство. Она прервётся, как только сможет исключить симметрию/треугольную структуру. Возвращаемое значение может быть использовано повторно для эффективного решения нескольких систем. Например: A=factorize(A); x=A\b; y=A\C.

Если factorize вызывается для эрмитовой положительно определённой матрицы, то factorize вернёт факторизацию Холецкого.

Примеры

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 Bidiagonal{Float64}, который теперь можно передать в другие функции линейной алгебры (например, решатели собственных значений), которые будут использовать специализированные методы для типов Bidiagonal.

Diagonal(V::AbstractVector)

Построение матрицы с V в качестве диагонали.

См. также diag, diagm.

Примеры

julia> 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

Diagonal(A::AbstractMatrix)

Построение матрицы из диагонали A.

Примеры

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

julia> Diagonal(A)
3×3 Diagonal{Int64, Vector{Int64}}:
 1  ⋅   ⋅
 ⋅  7   ⋅
 ⋅  ⋅  13

julia> diag(A, 2)
3-element Vector{Int64}:
  3
  9
 15

Diagonal{T}(undef, n)

Построение неинициализированного Diagonal{T} длиной n. См. undef.

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

Построение верхней (uplo=:U) или нижней (uplo=:L) блочно-диагональной матрицы с использованием заданных диагональных (dv) и внедиагональных (ev) векторов. Результат имеет тип Bidiagonal и обеспечивает эффективные специализированные линейные решатели, но может быть преобразован в обычную матрицу с помощью convert(Array, _) (или Array(_) для краткости). Длина ev должна быть на единицу меньше длины 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 is on the first subdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

Построение Bidiagonal матрицы из главной диагонали A и её первого наддиагонального (если uplo=: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(dv::V, ev::V) where V <: AbstractVector

Построение симметричной трёхдиагональной матрицы из диагональных элементов (dv) и первых под/наддиагональных элементов (ev) соответственно. Результат имеет тип SymTridiagonal и предоставляет эффективные специализированные решатели собственных значений, но может быть преобразован в обычную матрицу с помощью convert(Array, _) (или Array(_) для краткости).

Для блочных матриц SymTridiagonal элементы dv симметризуются. Аргумент ev интерпретируется как наддиагональный. Блоки из поддиагонали являются транспонированными соответсвующим наддиагональным блокам.

Примеры

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> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

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

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

julia> A[1,2]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[2,1]
2×2 Matrix{Int64}:
 1  3
 2  4

SymTridiagonal(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

Создайте треугольную матрицу из первой поддиагонали, диагонали и первой наддиагонали соответственно. Результат имеет тип Tridiagonal и обеспечивает эффективные специализированные линейные решатели, но может быть преобразован в обычную матрицу с помощью convert(Array, _) (или Array(_) для краткости). Длины dl и du должны быть на единицу меньше длины 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  0

Tridiagonal(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, uplo=:U)

Создайте представление Symmetric верхней (если uplo = :U) или нижней (если uplo = :L) треугольной части матрицы A.

Примеры

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]
5×5 Matrix{Int64}:
 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

julia> Supper = Symmetric(A)
5×5 Symmetric{Int64, Matrix{Int64}}:
 1  0  2  0  3
 0  4  0  5  0
 2  0  7  0  8
 0  5  0  1  0
 3  0  8  0  4

julia> Slower = Symmetric(A, :L)
5×5 Symmetric{Int64, Matrix{Int64}}:
 1  0  6  0  2
 0  4  0  9  0
 6  0  7  0  3
 0  9  0  1  0
 2  0  3  0  4

Обратите внимание, что Supper не будет равно Slower, если A сама не является симметричной (например, если A == transpose(A)).

Hermitian(A, uplo=:U)

Создайте представление Hermitian верхней (если uplo = :U) или нижней (если uplo = :L) треугольной части матрицы A.

Примеры

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];

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

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

Обратите внимание, что Hupper не будет равно Hlower, если A сама не является эрмитовой (например, если A == adjoint(A)).

Все комплексные части диагонали будут проигнорированы.

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

LowerTriangular(A::AbstractMatrix)

Создайте представление LowerTriangular матрицы 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)

Создайте представление UpperTriangular матрицы 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

UnitLowerTriangular(A::AbstractMatrix)

Создайте представление UnitLowerTriangular матрицы A. Такое представление имеет значение oneunit типа 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

UnitUpperTriangular(A::AbstractMatrix)

Создайте представление UnitUpperTriangular матрицы A. Такое представление имеет значение oneunit типа 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)

Создайте представление UpperHessenberg матрицы A. Элементы A ниже первой поддиагонали игнорируются.

Реализованы эффективные алгоритмы для H \ b, det(H) и аналогичных операций.

См. также функцию hessenberg для разложения любой матрицы в подобную верхнюю матрицу Гессенберга.

Если F::Hessenberg — объект разложения, унитарную матрицу можно получить с помощью F.Q, а матрицу Гессенберга — с помощью F.H. При извлечении Q, результирующий тип — объект HessenbergQ, который можно преобразовать в обычную матрицу с помощью convert(Array, _) (или Array(_) для краткости).

Итерация по разложению производит факторы 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. Хотя без явного size, он действует подобно матрице во многих случаях и включает поддержку некоторых индексов. См. также I.

Примеры

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

I

Объект типа UniformScaling, представляющий единичную матрицу любого размера.

Примеры

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

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

(I::UniformScaling)(n::Integer)

Создайте матрицу Diagonal из UniformScaling.

Примеры

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

Абстрактный тип для разложений матриц. См. онлайн документацию для списка доступных разложений матриц.

LU <: Factorization

Тип разложения матрицы LU разложения квадратной матрицы A. Это тип возвращаемого значения функции lu.

Индивидуальные компоненты разложения F::LU можно получить через getproperty:

Итерация по разложению производит компоненты 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

lu(A::SparseMatrixCSC; check = true) -> F::UmfpackLU

Вычислить LU-разложение разреженной матрицы A.

Для разреженной A с вещественным или комплексным типом элементов, тип возвращаемого значения F — UmfpackLU{Tv, Ti}, с Tv = Float64 или ComplexF64 соответственно и Ti — целочисленный тип (Int32 или Int64).

Если check = true, при неудачном разложении выбрасывается ошибка. Если check = false, ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Индивидуальные компоненты разложения F можно получить по индексу:

Связь между F и A:

F.L*F.U == (F.Rs .* A)[F.p, F.q]

F дополнительно поддерживает следующие функции:

• \
• det

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

Вычислить LU-разложение A.

Если check = true, то при неудачном разложении будет брошено исключение. Если check = false, то ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

В большинстве случаев, если A является подтипом S от AbstractMatrix{T} с типом элементов T, поддерживающим +, * и /, тип возвращаемого значения — LU{T,S{T}}. Если выбран поворот (по умолчанию), тип элементов также должен поддерживать abs и <. Поворот можно отключить, передав pivot = NoPivot().

Индивидуальные компоненты разложения F могут быть получены с помощью getproperty:

Итерируя разложение, получаем компоненты F.L, F.U и F.p.

Связь между F и A:

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

F дополнительно поддерживает следующие функции:

Примеры

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

lu!(F::UmfpackLU, A::SparseMatrixCSC; check=true) -> F::UmfpackLU

Вычислить LU-разложение разреженной матрицы A, повторно используя символическое разложение уже существующего LU-разложения, хранящегося в F. Разреженная матрица A должна иметь такой же набор ненулевых элементов, как и матрица, использованная для создания LU-разложения F; в противном случае будет брошено исключение.

Если check = true, то при неудачном разложении будет брошено исключение. Если check = false, то ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Примеры

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

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

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

lu! — это то же самое, что и lu, но экономит память, перезаписывая входные данные A вместо создания копии. Исключение InexactError выбрасывается, если разложение даёт число, не представимое типом элементов A, например, для целочисленных типов.

Примеры

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

Тип матричного разложения Холецкого для плотной симметричной/эрмитовой положительно определённой матрицы A. Это тип возвращаемого значения cholesky, соответствующей функции матричного разложения.

Треугольный фактор Холецкого может быть получен из разложения F::Cholesky с помощью F.L и F.U, где A ≈ F.U' * F.U ≈ F.L * F.L'.

Для объектов Cholesky доступны следующие функции: size, \, inv, det, logdet и isposdef.

Итерируя разложение, получаем компоненты 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

Тип матричного разложения с поворотом Холецкого для плотной симметричной/эрмитовой положительно полуопределённой матрицы A. Это тип возвращаемого значения cholesky(_, ::RowMaximum), соответствующей функции матричного разложения.

Треугольный фактор Холецкого может быть получен из разложения 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].

Для объектов CholeskyPivoted доступны следующие функции: size, \, inv, det и 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

Вычислить разложение Холецкого для плотной симметричной положительно определённой матрицы A и вернуть разложение Cholesky. Матрица A может быть как Symmetric, так и Hermitian AbstractMatrix, или идеально симметричной или эрмитовой AbstractMatrix.

Треугольный фактор Холецкого может быть получен из разложения F с помощью F.L и F.U, где A ≈ F.U' * F.U ≈ F.L * F.L'.

Для объектов Cholesky доступны следующие функции: size, \, inv, det, logdet и isposdef.

Если у вас есть матрица A, которая немного неээрмитова из-за ошибок округления при её построении, оберните её в Hermitian(A) перед передачей в cholesky, чтобы обращаться с ней как с идеально эрмитовой.

Если check = true, то при неудачном разложении будет брошено исключение. Если check = false, то ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Примеры

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

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

Вычислите поворотную факторизацию Холески плотной симметричной положительно полуопределённой матрицы A и верните факторизацию CholeskyPivoted. Матрица A может быть Symmetric или Hermitian AbstractMatrix, или совершенно симметричной или эрмитовой AbstractMatrix.

Треугольный фактор Холески может быть получен из факторизации 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].

Для объектов CholeskyPivoted доступны следующие функции: size, \, inv, det и rank.

Аргумент tol определяет допуск для определения ранга. Для отрицательных значений допуск равен машинной точности.

Если у вас есть матрица A, которая немного не эрмитова из-за ошибок округления при её построении, оберните её в Hermitian(A) перед передачей в cholesky, чтобы обработать её как идеально эрмитовую.

При check = true, ошибка выбрасывается, если разложение не выполняется. При check = false ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Примеры

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::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

Вычислите факторизацию Холески разреженной положительно определенной матрицы A. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если у A нет тега типа, она всё равно должна быть симметричной или эрмитовой. Если perm не задано, используется уменьшающая заполнение перестановка. F = cholesky(A) чаще всего используется для решения систем уравнений с F\b, но также определены методы diag, det и logdet для F. Вы также можете извлечь отдельные факторы из F, используя F.L. Однако, поскольку поворот включён по умолчанию, факторизация внутренне представляется как A == P'*L*L'*P с матрицей перестановок P; использование только L без учёта P даст неверные результаты. Для включения эффектов перестановки обычно предпочтительнее извлекать «комбинированные» факторы, такие как PtL = F.PtL (эквивалент P'*L) и LtP = F.UP (эквивалент L'*P).

При check = true, ошибка выбрасывается, если разложение не выполняется. При check = false ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Установка необязательного ключевого аргумента shift вычисляет факторизацию A+shift*I вместо A. Если аргумент perm задан, он должен представлять перестановку 1:size(A,1), определяющую используемую последовательность (вместо стандартной перестановки AMD библиотеки CHOLMOD).

Примеры

В следующем примере используемая перестановка, уменьшающая заполнение, равна [3, 2, 1]. Если perm установлено на 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))
SuiteSparse.CHOLMOD.Factor{Float64}
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);

julia> Matrix(L)
3×3 Matrix{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]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SuiteSparse.CHOLMOD.Factor{Float64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

То же, что и cholesky, но экономит память, перезаписывая входной A вместо создания копии. Исключение InexactError выбрасывается, если факторизация производит число, не представимое типом элементов A, например, для целочисленных типов.

Примеры

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

То же, что и cholesky, но экономит память, перезаписывая входной A вместо создания копии. Исключение InexactError выбрасывается, если факторизация производит число, не представимое типом элементов A, например, для целочисленных типов.

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

Вычислите факторизацию Холески ($LL'$) A, используя символическую факторизацию F. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если A не имеет тега типа, она всё равно должна быть симметричной или эрмитовой.

См. также cholesky.

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

Обновление факторизации Холески C вектором v. Если A = C.U'C.U, то CC = cholesky(C.U'C.U + v*v'), но вычисление CC использует только операции O(n^2).

lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Обратное обновление факторизации Холески C вектором v. Если A = C.U'C.U, то CC = cholesky(C.U'C.U - v*v'), но вычисление CC использует только операции O(n^2).

lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::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!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Обратное обновление факторизации Холески C вектором v. Если A = C.U'C.U, то CC = cholesky(C.U'C.U - v*v'), но вычисление CC использует только операции O(n^2). Входная факторизация C обновляется на месте так, что на выходе C == CC. Вектор v уничтожается во время вычисления.

LDLt <: Factorization

Тип факторизации матрицы LDLt факторизации вещественной SymTridiagonal матрицы S такой, что S = L*Diagonal(d)*L', где L — UnitLowerTriangular матрица и d — вектор. Основное использование факторизации LDLt F = ldlt(S) — решение системы линейных уравнений Sx = b с F\b. Это возвращаемый тип функции ldlt, соответствующей функции факторизации матриц.

Индивидуальные компоненты факторизации F::LDLt могут быть получены с помощью getproperty:

Примеры

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(S::SymTridiagonal) -> LDLt

Вычислите факторизацию LDLt (т.е. $LDL^T$) вещественной симметричной треугольной матрицы S таким образом, чтобы S = L*Diagonal(d)*L', где L — единичная нижняя треугольная матрица, а d — вектор. Основное применение факторизации LDLt F = ldlt(S) заключается в решении системы линейных уравнений Sx = b с F\b.

См. также bunchkaufman для аналогичной, но с выбором опор, факторизации произвольных симметричных или эрмитовых матриц.

Примеры

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

ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

Вычислите факторизацию $LDL'$ разреженной матрицы A. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если у A нет тега типа, она должна быть симметричной или эрмитовой. Используется заполняющая перестановка. F = ldlt(A) чаще всего используется для решения систем уравнений A*x = b с F\b. Возвращаемый объект факторизации F также поддерживает методы diag, det, logdet и inv. Вы можете извлечь отдельные факторы из F, используя F.L. Однако, поскольку перестановка включена по умолчанию, факторизация внутренне представлена как A == P'*L*D*L'*P с матрицей перестановки P; использование только L без учёта P даст неверные ответы. Для включения эффекта перестановки обычно предпочтительнее извлекать «комбинированные» факторы, такие как PtL = F.PtL (эквивалент P'*L) и LtP = F.UP (эквивалент L'*P). Полный список поддерживаемых факторов — :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

Если check = true, при неудачном разложении выбрасывается ошибка. Если check = false, ответственность за проверку корректности разложения (с помощью issuccess) ложится на пользователя.

Установка необязательного ключевого аргумента shift вычисляет факторизацию A+shift*I вместо A. Если аргумент perm предоставлен, он должен быть перестановкой 1:size(A,1), задающей порядок использования (вместо стандартного порядка AMD CHOLMOD).

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

ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

Вычислите факторизацию $LDL'$ A, используя символическую факторизацию F. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если у A нет тега типа, она должна быть симметричной или эрмитовой.

См. также ldlt.

QR <: Factorization

Факторизация матрицы QR, хранящаяся в упакованном формате, обычно получаемая из qr. Если $A$ — m×n матрица, то

\[A = Q R\]

где $Q$ — ортогональная/унитарная матрица, а $R$ — верхняя треугольная матрица. Матрица $Q$ хранится как последовательность отражений Хаусхолдера $v_i$ и коэффициентов $\tau_i$, где:

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

Итерация разложения порождает компоненты Q и R.

Объект имеет два поля:

• factors — m×n матрица.

  • Верхняя треугольная часть содержит элементы $R$, т.е. R = triu(F.factors) для объекта F типа QR.

  • Поддиагональная часть содержит отражения $v_i$, хранящиеся в упакованном формате, где $v_i$ — $i$-ый столбец матрицы V = I + tril(F.factors, -1).

• τ — вектор длины min(m,n), содержащий коэффициенты $au_i$.

QRCompactWY <: Factorization

Факторизация матрицы QR, хранящаяся в компактном блочном формате, обычно получаемая из qr. Если $A$ — m×n матрица, то

\[A = Q R\]

где $Q$ — ортогональная/унитарная матрица, а $R$ — верхняя треугольная матрица. Она похожа на формат QR, за исключением того, что ортогональная/унитарная матрица $Q$ хранится в формате Compact WY ^{[Schreiber1989]}. Для размера блока $n_b$ она хранится как нижняя трапециевидная матрица m×n $V$ и матрица $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$, составленная из $b = \lceil \min(m,n) / n_b \rceil$ верхних треугольных матриц $T_j$ размера $n_b$×$n_b$ ($j = 1, ..., b-1$) и верхней трапециевидной матрицы $n_b$×$\min(m,n) - (b-1) n_b$ $T_b'$ ($j=b$), чья верхняя квадратная часть обозначается $T_b$ и удовлетворяет условию

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

где $v_i$ — $i$-ый столбец $V$, $\tau_i$ — $i$-ый элемент [diag(T_1); diag(T_2); …; diag(T_b)], а $(V_1 \; V_2 \; ... \; V_b)$ — левая m×min(m, n) блочная часть $V$. При построении с помощью qr, размер блока равен $n_b = \min(m, n, 36)$.

Итерация разложения порождает компоненты Q и R.

Объект имеет два поля:

• factors, как в типе QR, — m×n матрица.

  • Верхняя треугольная часть содержит элементы $R$, т.е. R = triu(F.factors) для объекта F типа QR.

  • Поддиагональная часть содержит отражения $v_i$ в упакованном формате, так что V = I + tril(F.factors, -1).

• T — $n_b$-на-$\min(m,n)$ матрица, как описано выше. Поддиагональные элементы каждой треугольной матрицы $T_j$ игнорируются.

QRPivoted <: Factorization

Факторизация матрицы QR с выбором столбцов в упакованном формате, обычно получаемая из qr. Если $A$ — m×n матрица, то

\[A P = Q R\]

где $P$ — матрица перестановки, $Q$ — ортогональная/унитарная матрица, а $R$ — верхняя треугольная матрица. Матрица $Q$ хранится как последовательность отражений Хаусхолдера:

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

Итерация разложения порождает компоненты Q, R и p.

Объект имеет три поля:

• factors — m×n матрица.

  • Верхняя треугольная часть содержит элементы $R$, т.е. R = triu(F.factors) для объекта F типа QR.

  • Поддиагональная часть содержит отражения $v_i$, хранящиеся в упакованном формате, где $v_i$ — $i$-ый столбец матрицы V = I + tril(F.factors, -1).

• τ — вектор длины min(m,n), содержащий коэффициенты $au_i$.

• jpvt — целочисленный вектор длины n, соответствующий перестановке $P$.

qr(A, pivot = NoPivot(); blocksize) -> F

Вычислить QR-разложение матрицы A: ортогональную (или унитарную, если A комплекснозначная) матрицу Q и верхнетреугольную матрицу R, такие что

\[A = Q R\]

Возвращаемый объект F хранит разложение в упакованном формате:

• если pivot == ColumnNorm(), то F — объект QRPivoted,

• в противном случае, если тип элементов A — тип BLAS (Float32, Float64, ComplexF32 или ComplexF64), то F — объект QRCompactWY,

• в противном случае F — объект QR.

Отдельные компоненты разложения F могут быть получены с помощью аксессоров свойств:

• F.Q: ортогональная/унитарная матрица Q
• F.R: верхнетреугольная матрица R
• F.p: вектор перестановок поворота (QRPivoted только)
• F.P: матрица перестановок поворота (QRPivoted только)

Итерация разложения производит компоненты Q, R и, если существуют, p.

Для объектов QR доступны следующие функции: inv, size и \. Когда A прямоугольная, \ вернёт решение наименьших квадратов, а если решение не единственное, то вернёт решение с наименьшей нормой. Когда A не имеет полного ранга, требуется разложение с (столбцовым) поворотом для получения решения с минимальной нормой.

Разрешается умножение относительно как полной/квадратной, так и неполной/квадратной Q, т.е. поддерживаются как F.Q*F.R, так и F.Q*A. Матрицу Q можно преобразовать в обычную матрицу с помощью Matrix. Эта операция возвращает «тонкий» фактор Q, т.е., если A — m×n с m>=n, то Matrix(F.Q) возвращает матрицу m×n с ортонормированными столбцами. Для получения «полного» фактора Q, ортогональной матрицы m×m, используйте F.Q*I. Если m<=n, то Matrix(F.Q) возвращает ортогональную матрицу m×m.

Размер блока для QR-разложения можно указать с помощью ключевого аргумента blocksize :: Integer при pivot == NoPivot() и A isa StridedMatrix{<:BlasFloat}. Он игнорируется, когда blocksize > minimum(size(A)). См. QRCompactWY.

Примеры

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}}:
 -0.6   0.0   0.8
 -0.8   0.0  -0.6
  0.0  -1.0   0.0
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

Вычислить QR-разложение разреженной матрицы A. Используются уменьшающие заполнение строки и столбцы перестановок, так что F.R = F.Q'*A[F.prow,F.pcol]. Основное применение этого типа — решение задач наименьших квадратов или недоопределённых задач с \. Функция вызывает библиотеку C SPQR.

Примеры

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)
SuiteSparse.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SuiteSparse.SPQR.QRSparseQ{Float64, Int64}:
 -0.707107   0.0        0.0       -0.707107
  0.0       -0.707107  -0.707107   0.0
  0.0       -0.707107   0.707107   0.0
 -0.707107   0.0        0.0        0.707107
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
 2

qr!(A, pivot = NoPivot(); blocksize)

qr! аналогична qr, когда A — подтип StridedMatrix, но экономит память, перезаписывая входной параметр A вместо создания копии. Исключение InexactError выбрасывается, если разложение даёт число, не представимое типом элементов A, например, для целочисленных типов.

Примеры

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}}:
 -0.316228  -0.948683
 -0.948683   0.316228
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 <: Factorization

Тип матричного разложения LQ разложения матрицы A. LQ разложение — это QR разложение transpose(A). Это возвращаемый тип функции lq, соответствующей функции матричного разложения.

Если 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}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

lq(A) -> S::LQ

Вычислить LQ-разложение A. Нижнетреугольную компоненту разложения можно получить из объекта LQ S через S.L, а ортогональную/унитарную компоненту — через S.Q, так что A ≈ S.L*S.Q.

Итерация разложения производит компоненты S.L и S.Q.

LQ-разложение — это QR-разложение transpose(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}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

lq!(A) -> LQ

Вычислить LQ разложение A, используя входную матрицу как рабочее пространство. См. также lq.

BunchKaufman <: Factorization

Тип матричного разложения разложения Банча-Кафмана симметричной или эрмитовой матрицы A как P'UDU'P или P'LDL'P, в зависимости от того, верхняя (по умолчанию) или нижняя треугольная часть хранится в A. Если A комплексно-симметричная, то U' и L' обозначают несопряжённые транспонирования, т.е. transpose(U) и transpose(L) соответственно. Это возвращаемый тип функции bunchkaufman, соответствующей функции матричного разложения.

Если S::BunchKaufman — объект разложения, компоненты можно получить через S.D, S.U или S.L, соответственно, учитывая S.uplo и S.p.

Итерация разложения производит компоненты S.D, S.U или S.L, соответственно, учитывая S.uplo и S.p.

Примеры

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

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(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

Вычислите факторизацию Банча—Кауфмана ^[Bunch1977] симметричной или эрмитовой матрицы A как P'*U*D*U'*P или P'*L*D*L'*P, в зависимости от того, какой треугольник хранится в A, и верните объект BunchKaufman. Обратите внимание, что если A является комплексно-симметричной, то U' и L' обозначают несопряжённые транспонированные матрицы, т. е. transpose(U) и transpose(L).

Итерационное разложение производит компоненты S.D, S.U или S.L, соответственно, учитывая S.uplo и S.p.

Если rook является true, используется поворот по типу ферзя. Если rook равно false, поворот по типу ферзя не используется.

Если check = true, выбрасывается ошибка, если разложение не удаётся. Если check = false, ответственность за проверку корректности разложения (через issuccess) лежит на пользователе.

Для объектов BunchKaufman доступны следующие функции: size, \, inv, issymmetric, ishermitian, getindex.

Примеры

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

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(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman! совпадает с bunchkaufman, но экономит память, перезаписывая входной параметр A вместо создания копии.

Eigen <: Factorization

Тип факторизации матрицы для собственного/спектрального разложения квадратной матрицы A. Это возвращаемый тип функции eigen, соответствующей функции факторизации матрицы.

Если F::Eigen — это объект факторизации, собственные значения можно получить через F.values, а собственные векторы — как столбцы матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

Итерационное разложение производит компоненты F.values и F.vectors.

Примеры

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
true

GeneralizedEigen <: Factorization

Тип факторизации матрицы для обобщённого собственного/спектрального разложения A и B. Это возвращаемый тип функции eigen, соответствующей функции факторизации матрицы, при вызове с двумя матричными аргументами.

Если F::GeneralizedEigen — это объект факторизации, собственные значения можно получить через F.values, а собственные векторы — как столбцы матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

Итерационное разложение производит компоненты F.values и F.vectors.

Примеры

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.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

Возвращает собственные значения матрицы A.

Для общих несимметричных матриц можно указать, как балансировать матрицу перед вычислением собственных значений. Ключевые слова permute, scale и sortby аналогичны ключевым словам для eigen.

Примеры

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

Для скалярного входного значения eigvals вернёт скаляр.

Пример

julia> eigvals(-2)
-2

eigvals(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.0im

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

Возвращает собственные значения матрицы A. Можно вычислить только подмножество собственных значений, указав UnitRange irange, охватывающий индексы отсортированных собственных значений, например, 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

julia> eigvals(A, 2:2)
1-element Vector{Float64}:
 0.9999999999999996

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals(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!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

То же, что и eigvals, но экономит память, перезаписывая входной параметр A вместо создания копии. Ключевые слова permute, scale и sortby аналогичны ключевым словам для eigen.

Примеры

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

julia> eigvals!(A)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228

eigvals!(A, B; sortby) -> values

То же, что и eigvals, но экономит память, перезаписывая входные параметры 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.0

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

То же, что и eigvals, но экономит память, перезаписывая входной параметр A вместо создания копии. irange — это диапазон индексов собственных значений для поиска, например, 2-е по 8-е собственные значения.

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

То же, что и eigvals, но экономит память, перезаписывая входной параметр A вместо создания копии. vl — нижняя граница интервала для поиска собственных значений, а vu — верхняя граница.

eigmax(A; permute::Bool=true, scale::Bool=true)

Возвращает наибольшее собственное значение матрицы A. Опция permute=true переупорядочивает матрицу, приближая её к верхнетреугольной форме, а scale=true масштабирует матрицу на её диагональные элементы, чтобы сделать строки и столбцы более равными по норме. Обратите внимание, что если собственные значения 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. Опция permute=true переупорядочивает матрицу, приближая её к верхнетреугольной форме, а scale=true масштабирует матрицу на её диагональные элементы, чтобы сделать строки и столбцы более равными по норме. Обратите внимание, что если собственные значения A комплексные, этот метод завершится ошибкой, так как комплексные числа нельзя отсортировать.

Примеры

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

Возвращает матрицу M, столбцы которой — собственные векторы матрицы A. (k-й собственный вектор можно получить из среза M[:, k].)

Если задан необязательный вектор собственных значений eigvals, 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.5547001962252291

eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

Возвращает матрицу M, столбцы которой — собственные векторы матрицы A. (k-й собственный вектор можно получить из среза M[:, k].) Ключевые слова permute, scale и sortby аналогичны ключевым словам для eigen.

Примеры

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

eigvecs(A, B) -> Matrix

Возвращает матрицу M, столбцы которой — обобщённые собственные векторы матриц A и B. (k-й собственный вектор можно получить из среза 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, вернув объект факторизации Eigen F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

Итерация по разложению возвращает компоненты F.values и F.vectors.

Для объектов Eigen доступны следующие функции: inv, det и isposdef.

Для общих несимметричных матриц можно указать, как сбалансировать матрицу перед вычислением собственных векторов. Вариант permute=true переупорядочивает матрицу, чтобы она стала ближе к верхней треугольной, а вариант scale=true масштабирует матрицу по её диагональным элементам, чтобы сделать строки и столбцы более равными по норме. По умолчанию для обоих вариантов используется true.

По умолчанию собственные значения и векторы сортируются лексикографически по (real(λ),imag(λ)). Можно передать другую функцию сравнения by(λ) в sortby, или передать sortby=nothing, чтобы оставить собственные значения в произвольном порядке. Некоторые типы специальных матриц (например, Diagonal или SymTridiagonal) могут реализовывать собственную схему сортировки и не принимать ключевое слово sortby.

Примеры

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
true

eigen(A, B; sortby) -> GeneralizedEigen

Вычислите обобщённое разложение по собственным значениям A и B, вернув объект факторизации GeneralizedEigen F, содержащий обобщённые собственные значения в F.values и обобщённые собственные векторы в столбцах матрицы F.vectors. (k-й обобщённый собственный вектор можно получить из среза F.vectors[:, k].)

Итерация по разложению возвращает компоненты F.values и F.vectors.

По умолчанию собственные значения и векторы сортируются лексикографически по (real(λ),imag(λ)). Можно передать другую функцию сравнения by(λ) в sortby, или передать sortby=nothing, чтобы оставить собственные значения в произвольном порядке.

Примеры

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.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

Вычислите разложение по собственным значениям A, вернув объект факторизации Eigen F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

Итерация по разложению возвращает компоненты F.values и F.vectors.

Следующие функции доступны для объектов Eigen: inv, det и isposdef.

Диапазон UnitRange irange определяет индексы отсортированных собственных значений для поиска.

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

Вычислите разложение по собственным значениям A, вернув объект факторизации Eigen F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

Итерация по разложению возвращает компоненты F.values и F.vectors.

Следующие функции доступны для объектов Eigen: inv, det и isposdef.

vl — нижняя граница окна собственных значений для поиска, а vu — верхняя граница.

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

То же, что и eigen, но экономит память, перезаписывая входной A (и B) вместо создания копии.

Hessenberg <: Factorization

Объект Hessenberg представляет факторизацию Гамильтона–Кэли QHQ' квадратной матрицы или смещение Q(H+μI)Q', получаемые функцией hessenberg.

hessenberg(A) -> Hessenberg

Вычислите разложение Гессенберга для A и верните объект Hessenberg. Если F — это объект факторизации, то унитарную матрицу можно получить с помощью F.Q (типа LinearAlgebra.HessenbergQ), а матрицу Гессенберга — с помощью F.H (типа UpperHessenberg), которые можно преобразовать в обычную матрицу с помощью Matrix(F.H) или Matrix(F.Q).

Если A является Hermitian или вещественно-Symmetric, то разложение Гессенберга даёт вещественную симметричную тридиагональную матрицу, и F.H имеет тип SymTridiagonal.

Обратите внимание, что сдвинутую факторизацию A+μI = Q (H+μI) Q' можно эффективно создать с помощью F + μ*I, используя объект UniformScaling I, который создаёт новый объект Hessenberg с общим хранилищем и изменённым сдвигом. Сдвиг заданного 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}:
 1.0   0.0        0.0
 0.0  -0.707107  -0.707107
 0.0  -0.707107   0.707107
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

hessenberg!(A) -> Hessenberg

hessenberg! — это то же самое, что и hessenberg, но экономит память, перезаписывая входной A вместо создания копии.

Schur <: Factorization

Тип факторизации матрицы разложения Шура для матрицы A. Это возвращаемый тип функции schur(_).

Если F::Schur — объект факторизации, то (квази)треугольный фактор Шура можно получить с помощью F.Schur или F.T, а ортогональные/унитарные векторы Шура — с помощью F.vectors или F.Z так, что A = F.vectors * F.Schur * F.vectors'. Собственные значения A можно получить с помощью F.values.

Итерация по разложению возвращает компоненты F.T, F.Z и F.values.

Примеры

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
true

GeneralizedSchur <: Factorization

Тип факторизации матрицы обобщённого разложения Шура для двух матриц A и B. Это возвращаемый тип функции schur(_, _).

Если F::GeneralizedSchur — это объект факторизации, то (квази)треугольные факторы Шура можно получить с помощью F.S и F.T, левые унитарные/ортогональные векторы Шура — с помощью F.left или F.Q, а правые унитарные/ортогональные векторы Шура можно получить с помощью F.right или F.Z так, что A=F.left*F.S*F.right' и B=F.left*F.T*F.right'. Обобщённые собственные значения A и B можно получить с помощью F.α./F.β.

Итерация по разложению возвращает компоненты F.S, F.T, F.Q, F.Z, F.α и F.β.

schur(A) -> F::Schur

Вычисляет факторизацию Шура матрицы A. (Квази)треугольный фактор Шура можно получить из объекта Schur F с помощью либо F.Schur, либо F.T, а ортогональные/унитарные векторы Шура можно получить с помощью F.vectors или F.Z таким образом, что A = F.vectors * F.Schur * F.vectors'. Собственные значения A можно получить с помощью F.values.

Для вещественной матрицы A факторизация Шура является «квазитреугольной», что означает, что она является верхнетреугольной, за исключением 2×2 блоков по диагонали для каждой сопряжённой пары комплексных собственных значений; это позволяет факторизации быть чисто вещественной даже при наличии комплексных собственных значений. Для получения (комплексной) чисто верхнетреугольной факторизации Шура из вещественной квазитреугольной факторизации можно использовать Schur{Complex}(schur(A)).

Итерация разложения даёт компоненты F.T, F.Z и F.values.

Примеры

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
true

schur(A, B) -> F::GeneralizedSchur

Вычисляет обобщённую факторизацию Шура (или QZ) матриц A и B. (Квази)треугольные факторы Шура можно получить из объекта Schur F с помощью F.S и F.T, левые унитарные/ортогональные векторы Шура можно получить с помощью F.left или F.Q, а правые унитарные/ортогональные векторы Шура можно получить с помощью F.right или F.Z таким образом, что A=F.left*F.S*F.right' и B=F.left*F.T*F.right'. Обобщённые собственные значения A и B можно получить с помощью F.α./F.β.

Итерация разложения даёт компоненты F.S, F.T, F.Q, F.Z, F.α и F.β.

schur!(A::StridedMatrix) -> F::Schur

То же, что и schur, но использует входной аргумент A в качестве рабочей области.

Примеры

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> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

То же, что и schur, но использует входные матрицы A и B в качестве рабочей области.

ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

Переупорядочивает факторизацию Шура F матрицы A = Z*T*Z' в соответствии с логическим массивом select, возвращая переупорядоченную факторизацию F. Выбранные собственные значения появляются на главной диагонали F.Schur, а соответствующие ведущие столбцы F.vectors образуют ортогональную/унитарную основу соответствующего правого инвариантного подпространства. В вещественном случае пара сопряжённых комплексных собственных значений должна быть либо включена, либо исключена с помощью select.

ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

Переупорядочивает обобщённую факторизацию Шура F пары матриц (A, B) = (Q*S*Z', Q*T*Z') в соответствии с логическим массивом select и возвращает объект GeneralizedSchur F. Выбранные собственные значения появляются на главной диагонали как F.S, так и F.T, а левые и правые ортогональные/унитарные векторы Шура также переупорядочиваются таким образом, что (A, B) = F.Q*(F.S, F.T)*F.Z' по-прежнему выполняется, и обобщённые собственные значения A и B по-прежнему можно получить с помощью F.α./F.β.

ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

То же, что и ordschur, но перезаписывает факторизацию F.

ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

То же, что и ordschur, но перезаписывает факторизацию F.

SVD <: Factorization

Тип матричной факторизации сингулярного разложения (SVD) матрицы A. Это возвращаемый тип функции матричной факторизации svd(_).

Если F::SVD — объект факторизации, то U, S, V и Vt можно получить с помощью F.U, F.S, F.V и F.Vt таким образом, что A = U * Diagonal(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×N B,

• U — ортогональная матрица M×M,
• V — ортогональная матрица P×P,
• Q — ортогональная матрица N×N,
• D1 — диагональная матрица M×(K+L) с единицами в первых K элементах,
• D2 — матрица P×(K+L), правая верхняя блочная часть которой L×L — диагональная,
• R0 — матрица (K+L)×N, правая верхняя блочная часть которой (K+L)×(K+L) — невырожденная верхняя треугольная матрица,

K+L — эффективный числовой ранг матрицы [A; B].

Итерация разложения даёт компоненты U, V, Q, D1, D2 и R0.

Элементы F.D1 и F.D2 связаны, как описано в документации LAPACK для обобщённого SVD и процедуры xGGSVD3, которая вызывается внизу (в LAPACK 3.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(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

Вычислить сингулярное разложение (SVD) матрицы A и вернуть объект SVD.

U, S, V и Vt можно получить из факторизации F с помощью F.U, F.S, F.V и F.Vt, так что A = U * Diagonal(S) * Vt. Алгоритм производит Vt, поэтому извлечение Vt более эффективно, чем V. Сингулярные значения в S отсортированы в порядке убывания.

Итерация разложения даёт компоненты U, S и V.

Если full = false (по умолчанию), возвращается «узкое» SVD. Для матрицы $M \times N$ A в полной факторизации U — $M \times M$, а V — $N \times N$, в то время как в узкой факторизации U — $M \times K$, а V — $N \times K$, где $K = \min(M,N)$ — количество сингулярных значений.

Если alg = DivideAndConquer(), используется алгоритм «разделяй и властвуй» для вычисления SVD. Другой (обычно более медленный, но более точный) вариант — alg = QRIteration().

Примеры

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

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Вычислите обобщённое сингулярное разложение (ОСР) для A и B, вернув объект факторизации ОСР F, такой что [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U — ортогональная матрица размера M×M,
• V — ортогональная матрица размера P×P,
• Q — ортогональная матрица размера N×N,
• D1 — диагональная матрица размера M×(K+L) с единицами в первых K элементах,
• D2 — матрица размера P×(K+L), правая верхняя L×L блочная часть которой диагональна,
• R0 — матрица размера (K+L)×N, правая (K+L)×(K+L) блочная часть которой — невырожденная верхняя треугольная матрица,

K+L — эффективный числовой ранг матрицы [A; B].

Итеративное разложение производит компоненты U, V, Q, D1, D2 и R0.

Обобщённое сингулярное разложение используется в приложениях, например, когда нужно сравнить, сколько принадлежит A по сравнению с B, как в случае генома человека и дрожжей, сигнала и шума или между кластерами и внутри кластеров. (См. обсуждение в Edelman и Wang: https://arxiv.org/abs/1901.00485)

Оно разлагает [A; B] на [UC; VS]H, где [UC; VS] — естественный ортогональный базис для пространства столбцов [A; B], а H = RQ' — естественный неортогональный базис для пространства строк [A;B], где верхние строки наиболее тесно связаны с матрицей A, а нижние — с матрицей B. Матрицы многокосинусов/синусов C и A предоставляют многомерную меру того, сколько принадлежит A по сравнению с 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);

julia> U == Uonly
true

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

svd! — это то же самое, что svd, но экономит память, перезаписывая входной параметр A вместо создания копии. Подробности см. в документации к svd.

svd!(A, B) -> GeneralizedSVD

svd! — это то же самое, что svd, но изменяет аргументы A и B на месте вместо создания копий. Подробности см. в документации к svd.

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

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(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

svdvals!(A)

Возвращает сингулярные значения A, экономя память путём перезаписи входных данных. См. также svdvals и svd. ```

svdvals!(A, B)

Возвращает обобщённые сингулярные значения из обобщённого сингулярного разложения A и B, сохраняя память путём перезаписи A и B. См. также svd и svdvals.

LinearAlgebra.Givens(i1,i2,c,s) -> G

Линейный оператор вращения Гивенса. Поля c и s представляют косинус и синус угла вращения соответственно. Тип Givens поддерживает левое умножение G*A и сопряжённое транспонирование правого умножения A*G'. У типа нет поля size, поэтому его можно умножать на матрицы произвольного размера, если i2<=size(A,2) для G*A или i2<=size(A,1) для A*G'.

См. также givens.

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

Вычисляет вращение Гивенса G и скаляр r, такие что для любого вектора x, где

x[i1] = f
x[i2] = g

результат умножения

y = G*x

обладает свойством

y[i1] = r
y[i2] = 0

См. также LinearAlgebra.Givens.

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

Вычисляет вращение Гивенса G и скаляр r, такой что результат умножения

B = G*A

обладает свойством

B[i1,j] = r
B[i2,j] = 0

См. также LinearAlgebra.Givens.

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

Вычисляет вращение Гивенса G и скаляр r, такой что результат умножения

B = G*x

обладает свойством

B[i1] = r
B[i2] = 0

См. также LinearAlgebra.Givens.

triu(M)

Верхняя треугольная часть матрицы.

Примеры

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)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

Возвращает верхнюю треугольную часть M, начиная с k-й наддиагонали.

Примеры

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.

triu!(M, k::Integer)

Возвращает верхнюю треугольную часть M, начиная с k-й наддиагонали, перезаписывая 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)

Нижняя треугольная часть матрицы.

Примеры

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)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

Возвращает нижнюю треугольную часть M, начиная с k-й наддиагонали.

Примеры

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.

tril!(M, k::Integer)

Возвращает нижнюю треугольную часть M, начиная с k-й наддиагонали, перезаписывая 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> tril!(M, 2)
5×5 Matrix{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, k::Integer=0)

Массив, содержащий индексы k-й диагонали матрицы M.

См. также: diag, diagm, Diagonal.

Примеры

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

diag(M, k::Integer=0)

k-я диагональ матрицы как вектор.

См. также diagm, diagind, Diagonal, isdiag.

Примеры

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> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

Построение матрицы из диагоналей и векторов. Вектор kv.second будет размещён на kv.first диагонали. По умолчанию матрица квадратная, а её размер определяется по kv, но можно задать неквадратный размер m×n (дополнен нулями по мере необходимости), передав m,n в качестве первых аргументов. Для повторяющихся индексов диагоналей kv.first значения соответствующих векторов kv.second будут суммироваться.

diagm строит полную матрицу; если вам нужны варианты с компактным хранением и быстрыми арифметическими операциями, обратитесь к Diagonal, Bidiagonal, Tridiagonal и 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  0

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

Построение матрицы с элементами вектора как диагональными элементами. По умолчанию матрица квадратная и её размер задаётся значением length(v), но можно задать неквадратный размер m×n, передав m,n в качестве первых аргументов.

Примеры

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3

rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)

Вычислить ранг матрицы, посчитав, сколько сингулярных значений A имеют величину, большую, чем max(atol, rtol*σ₁), где σ₁ является наибольшим сингулярным значением A. atol и rtol — абсолюльная и относительная погрешности соответственно. По умолчанию относительная погрешность равна n*ϵ, где n — размер наименьшего измерения A, а ϵ — eps типа элементов A.

Примеры

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

norm(A, p::Real=2)

Для любого итерируемого контейнера A (включая массивы любой размерности) чисел (или любого типа элементов, для которых определен norm), вычислить p-норму (по умолчанию p=2) так, как будто A был вектором соответствующей длины.

p-норма определяется как

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

где $a_i$ — элементы $A$, $| a_i |$ — norm $a_i$, а $n$ — длина $A$. Поскольку p-норма вычисляется с использованием norm элементов A, p-норма вектора векторов не совместима с интерпретацией его как блочного вектора в общем случае, если p != 2.

p может принимать любое числовое значение (хотя не все значения дают математически корректную векторную норму). В частности, norm(A, Inf) возвращает наибольшее значение в abs.(A), а norm(A, -Inf) — наименьшее. Если A — матрица и p=2, то это эквивалентно норме Фробениуса.

Второй аргумент p необязательно является частью интерфейса для norm, т.е. пользовательский тип может реализовывать только norm(A) без второго аргумента.

Используйте opnorm для вычисления операторной нормы матрицы.

Примеры

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

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

Для чисел возвращается $\left( |x|^p \right)^{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 или Inf. (Обратите внимание, что для разреженных матриц p=2 пока не реализована.) Используйте norm для вычисления нормы Фробениуса.

Если p=1, операторная норма — это максимальная абсолютная сумма столбцов A:

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

где $a_{ij}$ — элементы $A$, а $m$ и $n$ — ее размеры.

Если p=2, операторная норма — спектральная норма, равная наибольшему сингулярному значению A.

Если p=Inf, операторная норма — максимальная абсолютная сумма строк A:

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

Примеры

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

opnorm(x::Number, p::Real=2)

Для чисел возвращается $\left( |x|^p \right)^{1/p}$. Это эквивалентно norm.

opnorm(A::Adjoint{<:Any,<:AbstracVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstracVector}, q::Real=2)

Для векторов с сопряжёнными/транспонированными обёртками возвращает операторную $q$-норму A, что эквивалентно p-норме со значением p = q/(q-1). Они совпадают при p = q = 2. Используйте norm для вычисления p-нормы A как вектора.

Разница в норме между векторным пространством и его двойственным возникает для сохранения связи между двойственностью и скалярным произведением, и результат согласуется с операторной p-нормой 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::AbstractArray, p::Real=2)

Нормализовать массив a на месте так, чтобы его p-норма была равна единице, т.е. norm(a, p) == 1. См. также normalize и norm.

normalize(a::AbstractArray, p::Real=2)

Нормализовать массив a так, чтобы его p-норма была равна единице, т.е. norm(a, p) == 1. См. также normalize! и norm.

Примеры

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

cond(M, p::Real=2)

Число обусловленности матрицы M, вычисленное с использованием операторной p-нормы. Допустимые значения для p — 1, 2 (по умолчанию) или Inf.

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

Число обусловленности по Скилу $\kappa_S$ матрицы M, необязательно относительно вектора x, вычисленное с использованием операторной p-нормы. $\left\vert M \right\vert$ обозначает матрицу (поэлементных) абсолютных значений $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Допустимые значения для p — 1, 2 и Inf (по умолчанию).

Эта величина также известна в литературе как число обусловленности по Бауэру, относительное число обусловленности или компонентное относительное число обусловленности.

tr(M)

След матрицы. Суммирует диагональные элементы M.

Примеры

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

julia> tr(A)
5

det(M)

Определитель матрицы.

См. также: logdet и logabsdet.

Примеры

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> det(M)
2.0

logdet(M)

Логарифм определителя матрицы. Эквивалентно log(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

logabsdet(M)

Логарифм абсолютного значения определителя матрицы. Эквивалентно (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)

inv(M)

Обратная матрица. Вычисляет матрицу N такую, что M * N = I, где I — единичная матрица. Вычисляется путём решения левого деления N = M \ I.

Примеры

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 == Matrix(I, 2, 2)
true

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, а ϵ — eps типа элементов M.

Для инвертирования плотных плохо обусловленных матриц в смысле наименьших квадратов рекомендуется rtol = sqrt(eps(real(float(one(eltype(M)))))).

Для получения дополнительной информации см. ^[issue8859], ^[B96], ^[S84], ^[KY88].

Примеры

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, а ϵ — eps типа элемента 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)

Кронекерово тензорное произведение двух векторов или двух матриц.

Для вещественных векторов v и w кронекерово произведение связано с внешним произведением выражениями kron(v,w) == vec(w * transpose(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  10

kron!(C, A, B)

kron! — это версия kron на месте. Вычисляет kron(A, B) и сохраняет результат в C, перезаписывая существующее значение C.

exp(A::AbstractMatrix)

Вычислить матричную экспоненту A, определённую выражением

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

Для симметричной или эрмитовой A используется собственное разложение (eigen), в противном случае выбирается алгоритм масштабирования и возведения в квадрат (см. ^[H05]).

Примеры

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

cis(A::AbstractMatrix)

Более эффективный метод для exp(im*A) квадратной матрицы A (особенно если A является Hermitian или вещественной Symmetric).

См. также cispi, sincos, exp.

Примеры

julia> cis([π 0; 0 π]) ≈ -I
true

^(A::AbstractMatrix, p::Number)

Степень матрицы, эквивалентная $\exp(p\log(A))$

Примеры

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

^(b::Number, A::AbstractMatrix)

Матричная экспонента, эквивалентная $\exp(\log(b)A)$.

Примеры

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

log(A::StridedMatrix)

Если A не имеет отрицательных действительных собственных значений, вычислите главную матричную логарифм A, т.е. единственную матрицу $X$ такую, что $e^X = A$ и $-\pi < Im(\lambda) < \pi$ для всех собственных значений $\lambda$ матрицы $X$. Если у A есть неположительные собственные значения, то возвращается неглавная матричная функция, когда это возможно.

Если A симметричная или эрмитова, используется её собственное разложение (eigen), если A треугольная, используется улучшенная версия алгоритма обратного масштабирования и возведения в квадрат (см. ^[AH12] и ^[AHR13]). Если A вещественная и не имеет отрицательных собственных значений, вычисляется её вещественная форма Шур. В противном случае вычисляется комплексная форма Шур. Затем используется алгоритм верхних (квази-)треугольных в ^[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(A::AbstractMatrix)

Если A не имеет отрицательных действительных собственных значений, вычислите главную матричную квадратный корень из A, т.е. единственную матрицу $X$ с собственными значениями, имеющими положительную действительную часть, такую что $X^2 = A$. В противном случае возвращается неглавный квадратный корень.

Если A вещественно-симметричная или эрмитова, используется её собственное разложение (eigen) для вычисления квадратного корня. Для таких матриц собственные значения λ, которые кажутся немного отрицательными из-за ошибок округления, обрабатываются так, как будто они равны нулю. Более точно, матрицы с все собственными значениями ≥ -rtol*(max |λ|) обрабатываются как полуопределённые (что даёт эрмитов квадратный корень), а отрицательные собственные значения принимаются равными нулю. rtol — ключевое слово для sqrt (только в случае эрмитовых/вещественно-симметричных матриц), по умолчанию равное машинной точности, умноженной на size(A,1).

В противном случае квадратный корень определяется с помощью метода Бьёрка-Хаммарлинга ^[BH83], который вычисляет комплексную форму Шур (schur) и затем комплексный квадратный корень из треугольного фактора. Если существует вещественный квадратный корень, то используется расширение этого метода ^[H87], которое вычисляет вещественную форму Шур, а затем вещественный квадратный корень из квазитреугольного фактора.

Примеры

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

cos(A::AbstractMatrix)

Вычислить матринный косинус квадратной матрицы A.

Если A симметричная или эрмитова, для вычисления косинуса используется её собственное разложение (eigen). В противном случае косинус определяется вызовом exp.

Примеры

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

Вычислить матринный синус квадратной матрицы A.

Если A симметричная или эрмитова, для вычисления синуса используется её собственное разложение (eigen). В противном случае синус определяется вызовом exp.

Примеры

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

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

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

Вычислить матринный тангенс квадратной матрицы A.

Если A симметричная или эрмитова, для вычисления тангенса используется её собственное разложение (eigen). В противном случае тангенс определяется вызовом exp.

Примеры

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

Вычислить матричную секусу квадратной матрицы A.

csc(A::AbstractMatrix)

Вычислить матричную косекусу квадратной матрицы A.

cot(A::AbstractMatrix)

Вычислить матричный котангенс квадратной матрицы A.

cosh(A::AbstractMatrix)

Вычислить матричный гиперболический косинус квадратной матрицы A.

sinh(A::AbstractMatrix)

Вычислить матричный гиперболический синус квадратной матрицы A.

tanh(A::AbstractMatrix)

Вычислить матричный гиперболический тангенс квадратной матрицы A.

sech(A::AbstractMatrix)

Вычислить матричную гиперболическую секанс квадратной матрицы A.

csch(A::AbstractMatrix)

Вычислить матричную гиперболическую косеканс квадратной матрицы A.

coth(A::AbstractMatrix)

Вычислить матричную гиперболическую котангенс квадратной матрицы A.

acos(A::AbstractMatrix)

Вычислить обратную матричную косинус квадратной матрицы A.

Если A является симметричной или эрмитовой, её собственное разложение (eigen) используется для вычисления обратной косинуса. В противном случае обратная косинус определяется с помощью log и sqrt. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_1].

Примеры

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

asin(A::AbstractMatrix)

Вычислить обратную матричную синус квадратной матрицы A.

Если A является симметричной или эрмитовой, её собственное разложение (eigen) используется для вычисления обратного синуса. В противном случае обратный синус определяется с помощью log и sqrt. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_2].

Примеры

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

atan(A::AbstractMatrix)

Вычислить обратную матричную тангенс квадратной матрицы A.

Если A является симметричной или эрмитовой, её собственное разложение (eigen) используется для вычисления обратной тангенса. В противном случае обратная тангенс определяется с помощью log. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_3].

Примеры

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

asec(A::AbstractMatrix)

Вычислить обратную матричную секанс A.

acsc(A::AbstractMatrix)

Вычислить обратную матричную косеканс A.

acot(A::AbstractMatrix)

Вычислить обратную матричную котангенс A.

acosh(A::AbstractMatrix)

Вычислить обратную гиперболическую матричную косинус квадратной матрицы A. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_4].

asinh(A::AbstractMatrix)

Вычислить обратную гиперболическую матричную синус квадратной матрицы A. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_5].

atanh(A::AbstractMatrix)

Вычислить обратную гиперболическую матричную тангенс квадратной матрицы A. Теория и логарифмические формулы, используемые для вычисления этой функции, см. в ^[AH16_6].

asech(A::AbstractMatrix)

Вычислить обратную матричную гиперболическую секанс A.

acsch(A::AbstractMatrix)

Вычислить обратную матричную гиперболическую косеканс A.

acoth(A::AbstractMatrix)

Вычислить обратную матричную гиперболическую котангенс A.

lyap(A, C)

Вычисляет решение X для непрерывного уравнения Лиувилля 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
2×2 Matrix{Float64}:
 0.0          6.66134e-16
 6.66134e-16  8.88178e-16

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
2×2 Matrix{Float64}:
  2.66454e-15  1.77636e-15
 -3.77476e-15  4.44089e-16

issuccess(F::Factorization)

Проверяет, успешно ли завершилась факторизация матрицы.

julia> F = cholesky([1 0; 0 1]);

julia> LinearAlgebra.issuccess(F)
true

julia> F = lu([1 0; 0 0]; check = false);

julia> LinearAlgebra.issuccess(F)
false

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

isposdef(A) -> Bool

Проверить, является ли матрица положительно определённой (и эрмитовой), попытавшись выполнить факторизацию Холецкого матрицы A.

См. также isposdef!, cholesky.

Примеры

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

Проверить, является ли матрица положительно определённой (и эрмитовой), попытавшись выполнить факторизацию Холецкого матрицы A, перезаписывая A в процессе. См. также isposdef.

Примеры

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

Проверить, является ли A нижнетреугольной, начиная с k-й наддиагонали.

Примеры

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

julia> b = [1 0; -im -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+0im
 0-1im  -1+0im

julia> istril(b)
true

julia> istril(b, -1)
false

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

Проверить, является ли A верхнетреугольной, начиная с k-й наддиагонали.

Примеры

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> b = [1 im; 0 -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+1im
 0+0im  -1+0im

julia> istriu(b)
true

julia> istriu(b, 1)
false

isdiag(A) -> Bool

Проверить, является ли матрица диагональной.

Примеры

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

ishermitian(A) -> Bool

Проверить, является ли матрица эрмитовой.

Примеры

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. Часто, но не всегда, возвращает Transpose(A), где Transpose — это оболочка леничной транспозиции. Обратите внимание, что эта операция рекурсивна.

Эта операция предназначена для использования в линейной алгебре — для общих операций с данными см. permutedims, которая не является рекурсивной.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3+2im  8+7im
 9+2im  4+6im

transpose!(dest,src)

Транспонировать массив src и сохранить результат в предварительно выделенном массиве dest, размер которого должен соответствовать (size(src,2),size(src,1)). Встроенная транспозиция не поддерживается, и непредсказуемые результаты будут получены, если src и dest имеют перекрывающиеся области памяти.

Примеры

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

Transpose

Ленивая оболочка для представления транспонированного вида базового объекта линейной алгебры, обычно AbstractVector/AbstractMatrix, но также и некоторые Factorization, например. Обычно конструктор Transpose не следует вызывать напрямую, используйте transpose вместо этого. Для материализации представления используйте copy.

Этот тип предназначен для использования в линейной алгебре — для общих манипуляций с данными см. permutedims.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3+2im  8+7im
 9+2im  4+6im

A'
adjoint(A)

Ленивый сопряженный транспонированный (сопряжённый переворот). Обратите внимание, что adjoint применяется рекурсивно к элементам.

Для числовых типов, adjoint возвращает комплексно сопряжённое значение, и, следовательно, эквивалентно тождественной функции для действительных чисел.

Эта операция предназначена для использования в линейной алгебре — для общих манипуляций с данными см. permutedims.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  8-7im
 9-2im  4-6im

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'x
25 + 0im

adjoint!(dest,src)

Матрица сопряжённого переворота src и сохранение результата в предварительно выделенном массиве dest, размер которого должен соответствовать (size(src,2),size(src,1)). Поддержка транспонирования на месте не поддерживается, и неожиданные результаты могут произойти, если src и dest имеют перекрывающиеся области памяти.

Примеры

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

Adjoint

Ленивая оболочка для представления сопряжённого переворота базового объекта линейной алгебры, обычно AbstractVector/AbstractMatrix, но также и некоторые Factorization, например. Обычно конструктор Adjoint не следует вызывать напрямую, используйте adjoint вместо этого. Для материализации представления используйте copy.

Этот тип предназначен для использования в линейной алгебре — для общих манипуляций с данными см. permutedims.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  8-7im
 9-2im  4-6im

copy(A::Transpose)
copy(A::Adjoint)

Сразу вычисляется ленивая матричная транспозиция/сопряжённый переворот. Обратите внимание, что транспозиция применяется рекурсивно к элементам.

Эта операция предназначена для использования в линейной алгебре — для общих манипуляций с данными см. permutedims, которая не рекурсивна.

Примеры

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

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=2000; parallel::Bool=false)

peakflops вычисляет пиковую скорость FLOPS компьютера, используя двойную точность gemm!. По умолчанию, если не указано никаких аргументов, она умножает матрицу размера n x n, где n = 2000. Если базовый BLAS использует несколько потоков, достигаются более высокие скорости FLOPS. Количество потоков BLAS можно установить с помощью BLAS.set_num_threads(n).

Если ключевой аргумент parallel установлен в true, peakflops выполняется параллельно на всех процессорах рабочих узлов. Возвращается скорость FLOPS всей параллельной вычислительной системы. При параллельной работе используется только 1 поток BLAS. Аргумент n всё ещё относится к размеру задачи, решаемой на каждом процессоре.

mul!(Y, A, B) -> Y

Вычисляет произведение матрица-матрица или матрица-вектор $AB$ и сохраняет результат в 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); mul!(Y, A, B);

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

Реализация

Для пользовательских типов матриц и векторов рекомендуется реализовывать 5-аргументную функцию mul!, а не реализовывать 3-аргументную функцию mul! напрямую, если это возможно.

mul!(C, A, B, α, β) -> C

Комбинированное умножение-сложение матриц на месте или матрица-вектор $A B α + C β$. Результат хранится в C, перезаписывая его. Обратите внимание, что C не должно быть ссылкой ни на A, ни на B.

Примеры

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> mul!(C, A, B, 100.0, 10.0) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

lmul!(a::Number, B::AbstractArray)

Масштабирует массив B на скаляр a, перезаписывая B на месте. Используйте rmul! для умножения скаляра справа. Операция масштабирования учитывает семантику умножения * между a и элементом B. В частности, это также относится к умножению, включающему бесконечные числа, такие как NaN и ±Inf.

Примеры

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}:
 NaN

lmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывает B и возвращает результат. Здесь A должен быть специального типа матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторого ортогонального типа, см. QR.

Примеры

julia> B = [0 1; 1 0];

julia> A = LinearAlgebra.UpperTriangular([1 2; 0 3]);

julia> LinearAlgebra.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]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

Масштабирует массив A на скаляр b, перезаписывая A на месте. Используйте lmul! для умножения скаляра слева. Операция масштабирования учитывает семантику умножения * между элементом A и b. В частности, это также относится к умножению, включающему бесконечные числа, такие как NaN и ±Inf.

Примеры

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}:
 NaN

rmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывает A и возвращает результат. Здесь B должен быть специального типа матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторого ортогонального типа, см. QR.

Примеры

julia> A = [0 1; 1 0];

julia> B = LinearAlgebra.UpperTriangular([1 2; 0 3]);

julia> LinearAlgebra.rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

Вычисляет A \ B на месте и сохраняет результат в Y, возвращая результат.

Аргумент A не должен быть матрицей. Вместо этого он должен быть объектом факторизации (например, полученным из factorize или cholesky). Причина в том, что сама факторизация является как дорогостоящей, так и обычно выделяет память (хотя это также можно сделать на месте, например, с помощью lu!), и в критически важных для производительности ситуациях, требующих ldiv!, обычно также требуется точный контроль над факторизацией A.

Примеры

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\X
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(A, B)

Вычислить A \ B на месте, перезаписывая B, чтобы сохранить результат.

Аргумент A не должен быть матрицей. Вместо матриц он должен быть объектом факторизации (например, полученным с помощью factorize или cholesky). Причина в том, что сама факторизация является дорогостоящей и обычно выделяет память (хотя это можно сделать на месте, например, с помощью lu!), а в критически важных для производительности ситуациях, требующих ldiv!, обычно также требуется точный контроль над факторизацией A.

Примеры

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(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

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

rdiv!(A, B)

Вычислить A / B на месте, перезаписывая A, чтобы сохранить результат.

Аргумент B не должен быть матрицей. Вместо матриц он должен быть объектом факторизации (например, полученным с помощью factorize или cholesky). Причина в том, что сама факторизация является дорогостоящей и обычно выделяет память (хотя это можно сделать на месте, например, с помощью 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.0

Интерфейс к подпрограммам BLAS.

dot(n, X, incx, Y, incy)

Скалярное произведение двух векторов, состоящих из n элементов массива X с шагом incx и n элементов массива Y с шагом incy.

Примеры

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 с шагом incy.

Примеры

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

Функция скалярного произведения для двух комплексных векторов, состоящих из n элементов массива X с шагом incx и n элементов массива U с шагом incy, сопрягая первый вектор.

Примеры

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

blascopy!(n, X, incx, Y, incy)

Скопировать n элементов массива X с шагом incx в массив Y с шагом incy. Возвращает Y.

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

axpy!(a, X, Y)

Перезаписать Y значением X*a + Y, где a — скаляр. Возвращает Y.

Примеры

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> BLAS.axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(a, X, b, Y)

Перезаписать Y значением X*a + Y*b, где a и b — скаляры. Возвращает Y.

Примеры

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

julia> y = [4., 5, 6];

julia> BLAS.axpby!(2., x, 3., y)
3-element Vector{Float64}:
 14.0
 19.0
 24.0

scal!(n, a, X, incx)
scal!(a, X)

Перезаписать X значением a*X для первых n элементов массива X с шагом incx. Возвращает X.

Если n и incx не предоставлены, используются length(X) и stride(X,1).

scal(n, a, X, incx)
scal(a, X)

Возвращает X, умноженный на a для первых n элементов массива X с шагом incx.

Если n и incx не предоставлены, используются length(X) и stride(X,1).

iamax(n, dx, incx)
iamax(dx)

Найдите индекс элемента dx с максимальным абсолютным значением. n — длина dx, а incx — шаг. Если n и incx не указаны, они принимают значения по умолчанию n=length(dx) и incx=stride1(dx) соответственно.

ger!(alpha, x, y, A)

Обновление матрицы A по формуле ранга 1 с векторами x и y в качестве alpha*x*y' + A.

syr!(uplo, alpha, x, A)

Обновление симметричной матрицы A по формуле ранга 1 с вектором x как alpha*x*transpose(x) + A. uplo определяет, какой треугольник матрицы A обновляется. Возвращает A.

syrk!(uplo, trans, alpha, A, beta, C)

Обновление симметричной матрицы C по формуле ранга k как alpha*A*transpose(A) + beta*C или alpha*transpose(A)*A + beta*C в соответствии с trans. Используется только uplo треугольник матрицы C. Возвращает C.

syrk(uplo, trans, alpha, A)

Возвращает верхний или нижний треугольник матрицы A, в зависимости от uplo, матрицы alpha*A*transpose(A) или alpha*transpose(A)*A, в зависимости от trans.

syr2k!(uplo, trans, alpha, A, B, beta, C)

Обновление симметричной матрицы C по формуле ранга 2k как alpha*A*transpose(B) + alpha*B*transpose(A) + beta*C или alpha*transpose(A)*B + alpha*transpose(B)*A + beta*C в соответствии с trans. Используется только uplo треугольник матрицы C. Возвращает C.

syr2k(uplo, trans, alpha, A, B)

Возвращает uplo треугольник матрицы alpha*A*transpose(B) + alpha*B*transpose(A) или alpha*transpose(A)*B + alpha*transpose(B)*A, в зависимости от trans.

syr2k(uplo, trans, A, B)

Возвращает uplo треугольник матрицы A*transpose(B) + B*transpose(A) или transpose(A)*B + transpose(B)*A, в зависимости от trans.

her!(uplo, alpha, x, A)

Методы для комплексных массивов. Обновление эрмитовой матрицы A по формуле ранга 1 с вектором x как alpha*x*x' + A. uplo определяет, какой треугольник матрицы A обновляется. Возвращает A.

herk!(uplo, trans, alpha, A, beta, C)

Методы для комплексных массивов. Обновление эрмитовой матрицы C по формуле ранга k как alpha*A*A' + beta*C или alpha*A'*A + beta*C в соответствии с trans. Используется только uplo треугольник матрицы C. Возвращает C.

herk(uplo, trans, alpha, A)

Методы для комплексных массивов. Возвращает uplo треугольник матрицы alpha*A*A' или alpha*A'*A, в зависимости от trans.

her2k!(uplo, trans, alpha, A, B, beta, C)

Обновление эрмитовой матрицы C по формуле ранга 2k как alpha*A*B' + alpha*B*A' + beta*C или alpha*A'*B + alpha*B'*A + beta*C в соответствии с trans. Скаляр beta должен быть вещественным. Используется только uplo треугольник матрицы C. Возвращает C.

her2k(uplo, trans, alpha, A, B)

Возвращает uplo треугольник матрицы alpha*A*B' + alpha*B*A' или alpha*A'*B + alpha*B'*A, в зависимости от trans.

her2k(uplo, trans, A, B)

Возвращает uplo треугольник матрицы A*B' + B*A' или A'*B + B'*A, в зависимости от trans.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

Обновление вектора y как alpha*A*x + beta*y или alpha*A'*x + beta*y в соответствии с trans. Матрица A — это общая полосовая матрица размера m на size(A,2) с kl поддиагоналями и ku наддиагоналями. alpha и beta — скаляры. Возвращает обновлённый y.

gbmv(trans, m, kl, ku, alpha, A, x)

Возвращает alpha*A*x или alpha*A'*x в соответствии с trans. Матрица A — это общая полосовая матрица размера m на size(A,2) с kl поддиагоналями и ku наддиагоналями, а alpha — скаляр.

sbmv!(uplo, k, alpha, A, x, beta, y)

Обновление вектора y как alpha*A*x + beta*y, где A — это симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Схема хранения для A описана в справочном модуле BLAS, уровень-2 BLAS по адресу http://www.netlib.org/lapack/explore-html/. Используется только uplo треугольник матрицы A.

Возвращает обновлённый y.

sbmv(uplo, k, alpha, A, x)

Возвращает alpha*A*x, где A — это симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Используется только uplo треугольник матрицы A.

sbmv(uplo, k, A, x)

Возвращает A*x, где A — это симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Используется только uplo треугольник матрицы A.

gemm!(tA, tB, alpha, A, B, beta, C)

Обновление C как alpha*A*B + beta*C или другие три варианта в соответствии с tA и tB. Возвращает обновлённый C.

gemm(tA, tB, alpha, A, B)

Возвращает alpha*A*B или другие три варианта в соответствии с tA и tB.

gemm(tA, tB, A, B)

Возвращает A*B или другие три варианта в соответствии с tA и tB.

gemv!(tA, alpha, A, x, beta, y)

Обновление вектора y как alpha*A*x + beta*y или alpha*A'x + beta*y в соответствии с tA. alpha и beta — скаляры. Возвращает обновлённый y.

gemv(tA, alpha, A, x)

Возвращает alpha*A*x или alpha*A'x в соответствии с tA. alpha — скаляр.

gemv(tA, A, x)

Возвращает A*x или A'x в соответствии с tA.

symm!(side, ul, alpha, A, B, beta, C)

Обновить C как alpha*A*B + beta*C или alpha*B*A + beta*C в соответствии с side. A предполагается симметричной. Используется только ul треугольник A. Вернуть обновлённый C.

symm(side, ul, alpha, A, B)

Вернуть alpha*A*B или alpha*B*A в соответствии с side. A предполагается симметричной. Используется только ul треугольник A.

symm(side, ul, A, B)

Вернуть A*B или B*A в соответствии с side. A предполагается симметричной. Используется только ul треугольник A.

symv!(ul, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y. A предполагается симметричной. Используется только ul треугольник A. alpha и beta являются скалярами. Вернуть обновлённый y.

symv(ul, alpha, A, x)

Вернуть alpha*A*x. A предполагается симметричной. Используется только ul треугольник A. alpha является скаляром.

symv(ul, A, x)

Вернуть A*x. A предполагается симметричной. Используется только ul треугольник A.

hemm!(side, ul, alpha, A, B, beta, C)

Обновить C как alpha*A*B + beta*C или alpha*B*A + beta*C в соответствии с side. A предполагается эрмитовой. Используется только ul треугольник A. Вернуть обновлённый C.

hemm(side, ul, alpha, A, B)

Вернуть alpha*A*B или alpha*B*A в соответствии с side. A предполагается эрмитовой. Используется только ul треугольник A.

hemm(side, ul, A, B)

Вернуть A*B или B*A в соответствии с side. A предполагается эрмитовой. Используется только ul треугольник A.

hemv!(ul, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y. A предполагается эрмитовой. Используется только ul треугольник A. alpha и beta являются скалярами. Вернуть обновлённый y.

hemv(ul, alpha, A, x)

Вернуть alpha*A*x. A предполагается эрмитовой. Используется только ul треугольник A. alpha является скаляром.

hemv(ul, A, x)

Вернуть A*x. A предполагается эрмитовой. Используется только ul треугольник A.

trmm!(side, ul, tA, dA, alpha, A, B)

Обновить B как alpha*A*B или один из других трёх вариантов, определённых side и tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице. Возвращает обновлённый B.

trmm(side, ul, tA, dA, alpha, A, B)

Возвращает alpha*A*B или один из других трёх вариантов, определённых side и tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице.

trsm!(side, ul, tA, dA, alpha, A, B)

Перезаписать B решением A*X = alpha*B или одним из других трёх вариантов, определённых side и tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице. Возвращает обновлённый B.

trsm(side, ul, tA, dA, alpha, A, B)

Вернуть решение A*X = alpha*B или один из других трёх вариантов, определённых side и tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице.

trmv!(ul, tA, dA, A, b)

Вернуть op(A)*b, где op определяется tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице. Умножение происходит непосредственно в b.

trmv(ul, tA, dA, A, b)

Вернуть op(A)*b, где op определяется tA. Используется только ul треугольник A. dA определяет, считываются или предполагаются диагональные значения равными единице.

trsv!(ul, tA, dA, A, b)

Перезаписать b решением A*x = b или одним из других двух вариантов, определённых tA и ul. dA определяет, считываются или предполагаются диагональные значения равными единице. Вернуть обновлённый b.

trsv(ul, tA, dA, A, b)

Вернуть решение A*x = b или один из других двух вариантов, определённых tA и ul. dA определяет, считываются или предполагаются диагональные значения равными единице.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Установить количество потоков, которое должна использовать библиотека BLAS, равное n::Integer.

Также принимает nothing, в этом случае Julia пытается угадать количество потоков по умолчанию. Передача nothing не рекомендуется и в основном существует по историческим причинам.

get_num_threads()

Получить количество потоков, используемых библиотекой BLAS.

Интерфейсы к подпрограммам LAPACK.

gbtrf!(kl, ku, m, AB) -> (AB, ipiv)

Вычисление LU-разложения полосовой матрицы AB. kl — это первая поддиагональ, содержащая ненулевую полосу, ku — последняя наддиагональ, содержащая единицу, а m — первая размерность матрицы AB. Возвращает LU-разложение на месте и ipiv, вектор опор.

gbtrs!(trans, kl, ku, m, AB, ipiv, B)

Решение уравнения AB * X = B. trans определяет ориентацию AB. Она может быть N (без транспонирования), T (транспонирование) или C (сопряжённое транспонирование). kl — это первая поддиагональ, содержащая ненулевую полосу, ku — последняя наддиагональ, содержащая единицу, а m — первая размерность матрицы AB. ipiv — это вектор опор, возвращённый из gbtrf!. Возвращает вектор или матрицу X, перезаписывая B на месте.

gebal!(job, A) -> (ilo, ihi, scale)

Балансировка матрицы A перед вычислением её собственных значений или факторизации Шура. job может быть одним из значений: N (A не будет переставлена или масштабирована), P (A будет только переставлена), S (A будет только масштабирована) или B (A будет и переставлена, и масштабирована). Изменяет A на месте и возвращает ilo, ihi и scale. Если перестановка была включена, A[i,j] = 0, если j > i и 1 < j < ilo или j > ihi. scale содержит информацию о выполненных масштабировании/перестановках.

gebak!(job, side, ilo, ihi, scale, V)

Преобразование собственных векторов V матрицы, сбалансированной с помощью gebal!, к несбалансированным/непереставленным собственным векторам исходной матрицы. Изменяет V на месте. side может быть L (преобразуются левые собственные векторы) или R (преобразуются правые собственные векторы).

gebrd!(A) -> (A, d, e, tauq, taup)

Приведение A на месте к бидиагональной форме A = QBP'. Возвращает A, содержащую бидиагональную матрицу B; d, содержащую диагональные элементы B; e, содержащую внедиагональные элементы B; tauq, содержащую элементарные отражатели, представляющие Q; и taup, содержащую элементарные отражатели, представляющие P.

gelqf!(A, tau)

Вычисление LQ факторизации A, A = LQ. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должна иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

gelqf!(A) -> (A, tau)

Вычисление LQ факторизации A, A = LQ.

Возвращает A, изменённую на месте, и tau, которая содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqlf!(A, tau)

Вычисление QL факторизации A, A = QL. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должна иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

geqlf!(A) -> (A, tau)

Вычисление QL факторизации A, A = QL.

Возвращает A, изменённую на месте, и tau, которая содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqrf!(A, tau)

Вычисление QR факторизации A, A = QR. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должна иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

geqrf!(A) -> (A, tau)

Вычисление QR факторизации A, A = QR.

Возвращает A, изменённую на месте, и tau, которая содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)

Вычисление пивотёной QR факторизации A, AP = QR с использованием уровня 3 BLAS. P — это матрица пивотов, представленная jpvt. tau хранит элементарные отражения. Аргументы jpvt и tau являются необязательными и позволяют передавать предварительно выделенные массивы. При передаче jpvt должна иметь длину не меньше n, если A — матрица, а tau должна иметь длину не меньше наименьшей размерности A.

A, jpvt и tau изменяются на месте.

gerqf!(A, tau)

Вычисление RQ факторизации A, A = RQ. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должна иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

gerqf!(A) -> (A, tau)

Вычисление RQ факторизации A, A = RQ.

Возвращает A, изменённую на месте, и tau, которая содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqrt!(A, T)

Вычисление блочной QR факторизации A, A = QR. T содержит верхние треугольные блочные отражения, которые параметризуют элементарные отражения факторизации. Первая размерность T задаёт размер блока и должна быть между 1 и n. Вторая размерность T должна быть равна наименьшей размерности A.

Возвращает A и T, изменённые на месте.

geqrt!(A, nb) -> (A, T)

Вычисление блочной QR факторизации A, A = QR. nb задаёт размер блока и должна быть между 1 и n, второй размерностью A.

Возвращает A, изменённую на месте, и T, которая содержит верхние треугольные блочные отражения, которые параметризуют элементарные отражения факторизации.

geqrt3!(A, T)

Рекурсивное вычисление блочной QR факторизации A, A = QR. T содержит верхние треугольные блочные отражения, которые параметризуют элементарные отражения факторизации. Первая размерность T задаёт размер блока и должна быть между 1 и n. Вторая размерность T должна быть равна наименьшей размерности A.

Возвращает A и T, изменённые на месте.

geqrt3!(A) -> (A, T)

Рекурсивное вычисление блочной QR факторизации A, A = QR.

Возвращает A, изменённую на месте, и T, которая содержит верхние треугольные блочные отражения, которые параметризуют элементарные отражения факторизации.

getrf!(A) -> (A, ipiv, info)

Вычислить разложение с выбором ведущих элементов матрицы LU матрицы A, A = LU.

Возвращает A, модифицированную на месте, ipiv, информацию о выборе ведущих элементов, и код info, указывающий на успех (info = 0), сингулярное значение в U (info = i, в этом случае U[i,i] является сингулярной), или код ошибки (info < 0).

tzrzf!(A) -> (A, tau)

Преобразует верхнюю треугольную матрицу A в верхнетреугольный вид на месте. Возвращает A и tau, скалярные параметры для элементарных отражателей преобразования.

ormrz!(side, trans, A, tau, C)

Умножает матрицу C на Q слева или справа, используя преобразование из tzrzf!. В зависимости от side или trans, умножение может быть слева (side = L, Q*C) или справа (side = R, C*Q), а Q может быть не модифицированным (trans = N), транспонированным (trans = T) или сопряжённо-транспонированным (trans = C). Возвращает матрицу C, которая модифицируется на месте результатом умножения.

gels!(trans, A, B) -> (F, B, ssr)

Решает линейное уравнение A * X = B, transpose(A) * X = B или adjoint(A) * X = B, используя QR или LQ разложение. Модифицирует матрицу/вектор B на месте с решением. A перезаписывается своим QR или LQ разложением. trans может быть одним из N (без модификации), T (транспонирование) или C (сопряжённое транспонирование). gels! ищет решение с минимальной нормой/методом наименьших квадратов. A может быть недоопределённым или переопределённым. Решение возвращается в B.

gesv!(A, B) -> (B, A, ipiv)

Решает линейное уравнение A * X = B, где A является квадратной матрицей, используя LU разложение LU матрицы A. A перезаписывается своим LU разложением, а B перезаписывается решением X. ipiv содержит информацию о выбоке ведущих элементов для LU разложения LU матрицы A.

getrs!(trans, A, ipiv, B)

Решает линейное уравнение A * X = B, transpose(A) * X = B или adjoint(A) * X = B для квадратной матрицы A. Модифицирует матрицу/вектор B на месте с решением. A — это LU разложение из getrf!, с ipiv, содержащим информацию о выбоке ведущих элементов. trans может быть одним из N (без модификации), T (транспонирование) или C (сопряжённое транспонирование).

getri!(A, ipiv)

Вычисляет обратную матрицу A, используя её LU разложение, найденное функцией getrf!. ipiv — это информация о выбоке ведущих элементов, а A содержит LU разложение getrf!. A перезаписывается своей обратной матрицей.

gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)

Решает линейное уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) используя LU разложение матрицы A. fact может быть E, в этом случае A будет выровнена и скопирована в AF; F, в этом случае AF и ipiv из предыдущего LU разложения являются входными данными; или N, в этом случае A будет скопирована в AF и затем разложена. Если fact = F, equed может быть N, означающим, что A не выровнена; R, означающим, что A была умножена на Diagonal(R) слева; C, означающим, что A была умножена на Diagonal(C) справа; или B, означающим, что A была умножена на Diagonal(R) слева и Diagonal(C) справа. Если fact = F и equed = R или B, элементы R должны быть положительными. Если fact = F и equed = C или B, элементы C должны быть положительными.

Возвращает решение X; equed, который является выходным, если fact не равно N, и описывает произведённое выравнивание; R, диагональ выравнивания строк; C, диагональ выравнивания столбцов; B, которая может быть перезаписана выровненной формой Diagonal(R)*B (если trans = N и equed = R,B) или Diagonal(C)*B (если trans = T,C и equed = C,B); rcond, обратная условная величина A после выравнивания; ferr, граница погрешности вперёд для каждого вектора решения в X; berr, граница погрешности вперёд для каждого вектора решения в X; и work, обратный фактор роста опорных элементов.

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, находя полное QR разложение 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 и левые собственные векторы в VL.

gesdd!(job, A) -> (U, S, VT)

Находит сингулярное разложение матрицы A, A = U * S * V', используя метод разделяй и властвуй. Если job = A, все столбцы U и строки V' вычисляются. Если job = N, столбцы U или строки V' не вычисляются. Если job = O, A перезаписывается столбцами (тонкой) матрицы U и строками (тонкой) матрицы V'. Если job = S, столбцы (тонкой) матрицы U и строки (тонкой) матрицы V' вычисляются и возвращаются отдельно.

gesvd!(jobu, jobvt, A) -> (U, S, VT)

Находит разложение по сингулярным значениям A, A = U * S * V'. Если jobu = A, вычисляются все столбцы U. Если jobvt = A, вычисляются все строки V'. Если jobu = N, не вычисляются никакие столбцы U. Если jobvt = N, не вычисляются никакие строки V'. Если jobu = O, A перезаписывается столбцами (тонкого) U. Если jobvt = O, A перезаписывается строками (тонкого) V'. Если jobu = S, столбцы (тонкого) U вычисляются и возвращаются отдельно. Если jobvt = S, строки (тонкого) V' вычисляются и возвращаются отдельно. jobu и jobvt не могут быть оба O.

Возвращает U, S и Vt, где S — сингулярные значения A.

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 имеет alpha на главной диагонали, а D2 имеет beta на главной диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq не N, эта матрица не вычисляется. Эта функция доступна только в версиях LAPACK до 3.6.0.

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 имеет alpha на главной диагонали, а D2 имеет beta на главной диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq не N, эта матрица не вычисляется. Данная функция требует LAPACK 3.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 переставляется, но не масштабируется. Если balanc = S, A масштабируется, но не переставляется. Если balanc = B, A переставляется и масштабируется. Если sense = N, обратные числовые характеристики не вычисляются. Если sense = E, обратные числовые характеристики вычисляются только для собственных значений. Если sense = V, обратные числовые характеристики вычисляются только для правых собственных векторов. Если sense = B, обратные числовые характеристики вычисляются для правых собственных векторов и векторов. Если sense = E,B, правые и левые собственные векторы должны быть вычислены.

ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)

Находит обобщенное собственное разложение A и B. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются.

gtsv!(dl, d, du, B)

Решает уравнение A * X = B, где A — треугольная матрица с dl на побочной диагонали, d на главной диагонали и du на наддиагональной.

Перезаписывает B решением X и возвращает его.

gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)

Находит факторизацию LU треугольной матрицы с dl на побочной диагонали, d на главной диагонали и du на наддиагональной.

Модифицирует dl, d и du на месте и возвращает их, а также вторую наддиагональ du2 и вектор поворота ipiv.

gttrs!(trans, dl, d, du, du2, ipiv, B)

Решает уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) с использованием факторизации LU, вычисленной функцией gttrf!. B перезаписывается решением X.

orglq!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации LQ после вызова gelqf! над A. Использует результат работы gelqf!. A перезаписывается значением Q.

orgqr!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации QR после вызова geqrf! над A. Использует результат работы geqrf!. A перезаписывается значением Q.

orgql!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации QL после вызова geqlf! над A. Использует результат работы geqlf!. A перезаписывается значением Q.

orgrq!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации RQ после вызова gerqf! над A. Использует результат работы gerqf!. A перезаписывается значением Q.

ormlq!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из факторизации LQ матрицы A, вычисленной с помощью gelqf!. C перезаписывается.

ormqr!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из факторизации QR матрицы A, вычисленной с помощью geqrf!. C перезаписывается.

ormql!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из факторизации QL матрицы A, вычисленной с помощью geqlf!. C перезаписывается.

ormrq!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из факторизации RQ матрицы A, вычисленной с помощью gerqf!. C перезаписывается.

gemqrt!(side, trans, V, T, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации Холеского A, вычисленной с помощью geqrt!. C перезаписывается.

posv!(uplo, A, B) -> (A, B)

Находит решение для A * X = B, где A — симметричная или эрмитова положительно определённая матрица. Если uplo = U, вычисляется верхняя факторизация Холеского A. Если uplo = L, вычисляется нижняя факторизация Холеского A. A перезаписывается своей факторизацией Холеского. B перезаписывается решением X.

potrf!(uplo, A)

Вычисляет факторизацию Холеского (верхнюю, если uplo = U, нижнюю, если uplo = L) положительно определённой матрицы A. A перезаписывается и возвращается с кодом информации.

potri!(uplo, A)

Вычисляет обратную матрицу A после вызова potrf! для нахождения её (верхней, если uplo = U, нижней, если uplo = L) факторизации Холеского.

A перезаписывается своей обратной матрицей и возвращается.

potrs!(uplo, A, B)

Находит решение для A * X = B, где A — симметричная или эрмитова положительно определённая матрица, чья факторизация Холеского была вычислена с помощью potrf!. Если uplo = U, была вычислена верхняя факторизация Холеского A. Если uplo = L, была вычислена нижняя факторизация Холеского A. B перезаписывается решением X.

pstrf!(uplo, A, tol) -> (A, piv, rank, info)

Вычисляет (верхнюю, если uplo = U, нижнюю, если uplo = L) факторизацию Холеского с выбором опорных элементов положительно определённой матрицы A с заданной точностью tol. A перезаписывается своей факторизацией Холеского.

Возвращает A, опорные элементы piv, ранг A и код info. Если info = 0, факторизация выполнена успешно. Если info = i > 0, то A является неопределённой или плохо обусловленной.

ptsv!(D, E, B)

Решает A * X = B для положительно определённой трёхдиагональной матрицы A. D — диагональ A, а E — внедиагональ. B перезаписывается решением X и возвращается.

pttrf!(D, E)

Вычисляет факторизацию LDLt положительно определённой трёхдиагональной матрицы с D на диагонали и E на внедиагонали. D и E перезаписываются и возвращаются.

pttrs!(D, E, B)

Решает A * X = B для положительно определённой трёхдиагональной матрицы A с диагональю D и внедиагональю E после вычисления факторизации LDLt A с помощью pttrf!. B перезаписывается решением X.

trtri!(uplo, diag, A)

Находит обратную (верхнюю, если uplo = U, нижнюю, если uplo = L) треугольной матрицы A. Если diag = N, A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы A равны единице. A перезаписывается своей обратной матрицей.

trtrs!(uplo, trans, diag, A, B)

Решает A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) для (верхней, если uplo = U, нижней, если uplo = L) треугольной матрицы A. Если diag = N, A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы A равны единице. B перезаписывается решением X.

trcon!(norm, uplo, diag, A)

Находит обратную условную (определённую) число матрицы (верхней, если uplo = U, нижней, если uplo = L) треугольной матрицы A. Если diag = N, A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы A равны единице. Если norm = I, условная определённость ищется в норме бесконечности. Если norm = O или 1, условная определённость ищется в норме единицы.

trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))

Находит систему собственных значений верхней треугольной матрицы T. Если side = R, вычисляются правые собственные векторы. Если side = L, вычисляются левые собственные векторы. Если side = B, вычисляются оба набора. Если howmny = A, находятся все собственные векторы. Если howmny = B, все собственные векторы находятся и повторно преобразуются с помощью VL и VR. Если howmny = S, вычисляются только собственные векторы, соответствующие значениям в select.

trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)

Оценивает ошибку в решении A * X = B (trans = N), transpose(A) * X = B (trans = T), adjoint(A) * X = B (trans = C) для side = L или эквивалентных уравнений с правым умножением side = R X * A после вычисления X с помощью trtrs!. Если uplo = U, A — верхняя треугольная матрица. Если uplo = L, A — нижняя треугольная матрица. Если diag = N, A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы A равны единице. Ferr и Berr — необязательные входные данные. Ferr — прямая ошибка, а Berr — обратная ошибка, каждая компонентно.

stev!(job, dv, ev) -> (dv, Zmat)

Вычисляет систему собственных значений для симметричной трёхдиагональной матрицы с dv на диагонали и ev на внедиагонали. Если job = N, вычисляются только собственные значения и возвращаются в dv. Если job = V, вычисляются также собственные векторы и возвращаются в Zmat.

stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)

Вычисляет собственные значения симметричной трёхдиагональной матрицы с dv на диагонали и ev на внедиагонали. Если range = A, все собственные значения находятся. Если range = V, находятся собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, находятся собственные значения с индексами между il и iu. Если order = B, собственные значения упорядочены внутри блока. Если order = E, они упорядочены по всем блокам. abstol может быть задано как допуск сходимости.

stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)

Вычисляет собственные значения (jobz = N) или собственные значения и векторы (jobz = V) для симметричной трёхдиагональной матрицы с dv на диагонали и ev на внедиагонали. Если range = A, все собственные значения находятся. Если range = V, собственные значения в полуоткрытом интервале (vl, vu] находятся. Если range = I, собственные значения с индексами между il и iu находятся. Собственные значения возвращаются в w, а собственные векторы — в Z.

stein!(dv, ev_in, w_in, iblock_in, isplit_in)

Вычисляет собственные векторы для симметричной трёхдиагональной матрицы с dv на диагонали и ev_in на внедиагонали. w_in задаёт входные собственные значения, для которых требуется найти соответствующие собственные векторы. iblock_in задаёт подматрицы, соответствующие собственным значениям в w_in. isplit_in задаёт точки разделения между блоками подматриц.

syconv!(uplo, A, ipiv) -> (A, work)

Преобразует симметричную матрицу A (которая была разложена в треугольную матрицу) в две матрицы L и D. Если uplo = U, то A является верхней треугольной матрицей. Если uplo = L, то она является нижней треугольной матрицей. ipiv — это вектор поворота из треугольного разложения. A перезаписывается значениями L и D.

sysv!(uplo, A, B) -> (B, A, ipiv)

Находит решение для A * X = B для симметричной матрицы A. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. B перезаписывается решением X. A перезаписывается результатом факторизации Банча-Кофмана. ipiv содержит информацию о поворотах при факторизации.

sytrf!(uplo, A) -> (A, ipiv, info)

Вычисляет факторизацию Банча-Кофмана симметричной матрицы A. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится.

Возвращает A, перезаписанную факторизацией, вектор поворота ipiv и код ошибки info, который является неотрицательным целым числом. Если info положительно, матрица вырождена, и диагональная часть факторизации равна нулю в позиции info.

sytri!(uplo, A, ipiv)

Вычисляет обратную матрицу симметричной матрицы A, используя результаты sytrf!. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. A перезаписывается её обратной матрицей.

sytrs!(uplo, A, ipiv, B)

Решает уравнение A * X = B для симметричной матрицы A, используя результаты sytrf!. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. B перезаписывается решением X.

hesv!(uplo, A, B) -> (B, A, ipiv)

Находит решение для A * X = B для эрмитовой матрицы A. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. B перезаписывается решением X. A перезаписывается её факторизацией Банча-Кофмана. ipiv содержит информацию о поворотах при факторизации.

hetrf!(uplo, A) -> (A, ipiv, info)

Вычисляет факторизацию Банча-Кофмана эрмитовой матрицы A. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится.

Возвращает A, перезаписанную факторизацией, вектор поворота ipiv и код ошибки info, который является неотрицательным целым числом. Если info положительно, матрица вырождена, и диагональная часть факторизации равна нулю в позиции info.

hetri!(uplo, A, ipiv)

Вычисляет обратную матрицу эрмитовой матрицы A, используя результаты sytrf!. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. A перезаписывается её обратной матрицей.

hetrs!(uplo, A, ipiv, B)

Решает уравнение A * X = B для эрмитовой матрицы A, используя результаты sytrf!. Если uplo = U, то верхняя часть A хранится. Если uplo = L, то нижняя часть хранится. B перезаписывается решением X.

syev!(jobz, uplo, A)

Находит собственные значения (jobz = N) или собственные значения и векторы (jobz = V) симметричной матрицы A. Если uplo = U, то используется верхняя треугольная часть A. Если uplo = L, то используется нижняя треугольная часть A.

syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)

Находит собственные значения (jobz = N) или собственные значения и векторы (jobz = V) симметричной матрицы A. Если uplo = U, то используется верхняя треугольная часть A. Если uplo = L, то используется нижняя треугольная часть A. Если range = A, то находятся все собственные значения. Если range = V, то находятся собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, то находятся собственные значения с индексами между il и iu. abstol может быть установлено как толерантность для сходимости.

Собственные значения возвращаются в W, а собственные векторы — в Z.

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

Находит обобщенные собственные значения (jobz = N) или собственные значения и векторы (jobz = V) симметричной матрицы A и симметричной положительно определённой матрицы B. Если uplo = U, то используются верхние треугольные части A и B. Если uplo = 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!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на побочной диагонали. Если uplo = U, то e_ — это наддиагональ. Если uplo = L, то e_ — это поддиагональ. Также можно (по выбору) вычислить произведение Q' * C.

Возвращает сингулярные значения в d, а матрица C перезаписывается значением Q' * C.

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на побочной диагонали, используя метод деления и завоевания. Если uplo = U, то e_ — это наддиагональ. Если uplo = L, то e_ — это поддиагональ. Если compq = N, то находятся только сингулярные значения. Если compq = I, то находятся сингулярные значения и векторы. Если compq = P, то сингулярные значения и векторы находятся в компактной форме. Работает только для вещественных типов.

Возвращает сингулярные значения в d, а если compq = P, то компактные сингулярные векторы в iq.

gecon!(normtype, A, anorm)

Находит обратную величину условного числа матрицы A. Если normtype = I, то условное число находится в норме бесконечности. Если normtype = O или 1, то условное число находится в норме единицы. A должно быть результатом getrf!, а anorm — нормой A в соответствующей норме.

gehrd!(ilo, ihi, A) -> (A, tau)

Преобразует матрицу A к эссенберг-форме. Если A сбалансирована с помощью gebal!, то ilo и ihi — результаты gebal!. В противном случае они должны быть ilo = 1 и ihi = size(A,2). tau содержит элементарные отражения факторизации.

orghr!(ilo, ihi, A, tau)

Явно находит Q, ортогональную/унитарную матрицу из gehrd!. ilo, ihi, A, и tau должны соответствовать входным/выходным данным для gehrd!.

gees!(jobvs, A) -> (A, vs, w)

Вычисляет собственные значения (jobvs = N) или собственные значения и векторы Шур (jobvs = V) матрицы A. A перезаписывается своей формой Шур.

Возвращает A, vs, содержащий векторы Шур, и w, содержащий собственные значения.

gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)

Вычисляет обобщённые собственные значения, обобщённую форму Шур, левые векторы Шур (jobsvl = V) или правые векторы Шур (jobvsr = V) матриц A и B.

Обобщённые собственные значения возвращаются в alpha и beta. Левые векторы Шур возвращаются в vsl, а правые векторы Шур — в vsr.

trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)

Переупорядочивает факторизацию Шур T матрицы таким образом, чтобы диагональный блок T с индексом строки ifst был перемещён в строку с индексом ilst. Если compq = V, векторы Шур Q переупорядочиваются. Если compq = N, они не изменяются. Метод с 4 аргументами вызывает метод с 5 аргументами с compq = V.

trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)

Переупорядочивает факторизацию Шур матрицы и необязательно находит обратные числа обусловленности. Если job = N, числа обусловленности не находятся. Если job = E, находится только число обусловленности для этого кластера собственных значений. Если job = V, находится только число обусловленности для инвариантного подпространства. Если job = B, находятся числа обусловленности для кластера и подпространства. Если compq = V, векторы Шур Q обновляются. Если compq = N, векторы Шур не изменяются. select определяет, какие собственные значения находятся в кластере. Метод с 3 аргументами вызывает метод с 5 аргументами с job = N и compq = V.

Возвращает T, Q, переупорядоченные собственные значения в w, число обусловленности кластера собственных значений s и число обусловленности инвариантного подпространства sep.

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщённого разложения Шур. select указывает собственные значения в каждом кластере.

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

Решает уравнение Сильвестра A * X +/- X * B = scale*C, где A и B являются квазиверхнетреугольными. Если transa = N, A не изменяется. Если transa = T, A транспонируется. Если transa = C, A сопряжённо транспонируется. Аналогично для transb и B. Если isgn = 1, решается уравнение A * X + X * B = scale * C. Если isgn = -1, решается уравнение A * X - X * B = scale * C.

Возвращает X (перезаписывая C) и scale.