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

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

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

dot(x, y)
x ⋅ y

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

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

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

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

axpy!(α, x::AbstractArray, y::AbstractArray)

Перезаписывает y значением x * α + y и возвращает y. Если x и y имеют одинаковые оси, это эквивалентно y .+= x .* a.

Примеры

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

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

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

axpby!(α, x::AbstractArray, β, y::AbstractArray)

Перезаписывает y значением x * α + y * β и возвращает y. Если x и y имеют одинаковые оси, это эквивалентно y .= x .* a .+ y .* β.

Примеры

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

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

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

Перезаписывает x значением c*x + s*y и y значением -conj(s)*x + c*y. Возвращает x и y.

reflect!(x, y, c, s)

Перезаписывает x значением c*x + s*y и y значением conj(s)*x - c*y. Возвращает x и y.

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::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

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

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

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

Перестановка q может быть вектором перестановок или nothing. Если вектор перестановок не предоставлен или q — nothing, используется значение по умолчанию UMFPACK. Если перестановка не основана на нулевом индексе, создается копия с нулевым основанием.

Вектор control по умолчанию использует конфигурации пакета для umfpacks, но его можно изменить, передав вектор длиной UMFPACK_CONTROL. Возможные конфигурации см. в руководстве UMFPACK. Соответствующие переменные называются JL_UMFPACK_, так как Julia использует индексацию с единицы.

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

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

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

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

• \
• det

См. также lu!

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

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

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

В большинстве случаев, если A — подтип S от AbstractMatrix{T} с типом элементов T, поддерживающим +, -, * и /, возвращаемый тип — LU{T,S{T}}.

В общем случае LU-разложение подразумевает перестановку строк матрицы (соответствующую выводу F.p ниже), известную как "пивотирование" (потому что это соответствует выбору строки, содержащей "опорный" элемент, диагональный элемент F.U).

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

• RowMaximum() (по умолчанию): стандартный метод пивотирования; опорный элемент соответствует элементу максимального абсолютного значения среди оставшихся строк, подлежащих факторизации. Этот метод требует, чтобы тип элементов также поддерживал abs и <. (Это, как правило, единственный численный стабильный вариант для матриц с плавающей точкой.)
• RowNonZero(): опорный элемент соответствует первому ненулевому элементу среди оставшихся строк, подлежащих факторизации. (Это соответствует обычному выбору при ручных вычислениях и также полезно для более общих типов алгебраических чисел, которые поддерживают iszero, но не abs или <.)
• 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::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

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

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

Перестановка q может быть вектором перестановок или nothing. Если вектор перестановок не предоставлен или q — nothing, используется значение по умолчанию UMFPACK. Если перестановка не основана на нулевом индексе, создается копия с нулевым основанием.

См. также lu

Примеры

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::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))
SparseArrays.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)
SparseArrays.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, 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].

Аргумент 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!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

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

См. также cholesky.

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, например, для целочисленных типов.

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(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 (т.е. $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!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

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

См. также ldlt.

ldlt!(S::SymTridiagonal) -> LDLt

Аналогично ldlt, но экономит место, перезаписывая входные данные S, а не создавая копию.

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

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) для объекта QR F.

  • Поддиагональная часть содержит отражатели $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) для объекта QR F.

  • Поддиагональная часть содержит отражения $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) для объекта QR F.

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

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

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

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

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

Примеры

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Row permutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Column permutation:
2-element Vector{Int64}:
 1
 2

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, 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 — это диапазон индексов собственных значений для поиска.

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) -> 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) матрица с 1 на первых 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

Вычислите обобщенное сингулярное разложение (GSVD) A и B, возвращая объект факторизации GeneralizedSVD 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.

Обобщенное SVD используется в приложениях, например, когда нужно сравнить, сколько принадлежит 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 и S предоставляют многомерную оценку того, сколько принадлежит 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)

Массив индексов AbstractRange для 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}...)

Построение матрицы из Pair диагоналей и векторов. Вектор 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(::QRSparse{Tv,Ti}) -> Ti

Возвращает ранг QR-разложения.

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

Вычисление ранга S путём вычисления его QR-разложения. Значения, меньшие tol, считаются нулями. См. руководство по SPQR.

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, p::Real=2)

Нормализация a так, чтобы его p-норма была равна единице, т.е. norm(a, p) == 1. Для скаляров это похоже на sign(a), за исключением normalize(0) = NaN. См. также normalize!, norm и sign.

Примеры

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

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

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(oneunit(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)

Вычисляет кронекеровское произведение A и B и сохраняет результат в C, перезаписывая существующее содержимое C. Это версия функции kron для работы inplace.

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::AbstractMatrix)

Если 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(x)

Возвращает $\sqrt{x}$. Выбрасывает DomainError для отрицательных вещественных аргументов. Используйте комплексные отрицательные аргументы вместо этого. Префиксный оператор √ эквивалентен sqrt.

См. также: hypot.

Примеры

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

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

Если A вещественная симметричная или эрмитова, используется её собственное разложение (eigen) для вычисления квадратного корня. Для таких матриц собственные значения λ, которые кажутся немного отрицательными из-за ошибок округления, обрабатываются так, как если бы они были равны нулю. Более точно, матрицы с полностью неотрицательными собственными значениями рассматриваются как полуопределенные (что даёт эрмитов квадратный корень), а отрицательные собственные значения принимаются равными нулю. 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
true

sylvester(A, B, C)

Вычисляет решение X для уравнения Сильвестра AX + XB + C = 0, где A, B и C имеют совместимые размеры и у A и -B нет собственных значений с равными действительными частями.

Примеры

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

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

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

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

julia> issuccess(F)
true

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

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

Проверка, является ли матрица диагональной в том смысле, что iszero(A[i,j]) истинно, если i == j. Обратите внимание, что A не обязательно должна быть квадратной; если вы также хотите проверить это, вам нужно проверить, что size(A, 1) == size(A, 2).

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

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

julia> isdiag(c)
true

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

julia> isdiag(d)
false

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 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # the transpose of a transpose unwraps the parent
true

julia> Transpose(B) # however, the constructor always wraps its argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # modifying B will modify A automatically

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

Для комплексных матриц операция adjoint эквивалентна сопряжённо-транспонированию.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

Транспонирование transpose AbstractVector представляет собой строчный вектор:

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # compute the dot product
14

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет результат в матрице X. size(X) должна быть равна size(transpose(A)). Дополнительная память не выделяется, за исключением изменения размеров rowval и nzval у X, если это необходимо.

См. halfperm!

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 = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

A'
adjoint(A)

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

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

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

Примеры

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

julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # the adjoint of an adjoint unwraps the parent
true

julia> Adjoint(B) # however, the constructor always wraps its argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # modifying B will modify A automatically

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Для вещественных матриц операция adjoint эквивалентна операции transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

Сопряжённое транспонирование AbstractVector представляет собой строчный вектор:

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

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # compute the dot product, equivalently x' * x
25 + 0im

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет сопряжённое транспонирование элементов в матрице X. size(X) должна быть равна size(transpose(A)). Дополнительная память не выделяется, за исключением изменения размеров rowval и nzval у X, если это необходимо.

См. halfperm!

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; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

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 вычисляет пиковую скорость выполнения операций с плавающей запятой на компьютере, используя двойную точность gemm!. По умолчанию, если не указаны аргументы, она умножает матрицу размера n x n, где n = 2000. Если базовый BLAS использует несколько потоков, достигается более высокая скорость выполнения операций. Количество потоков BLAS можно установить с помощью BLAS.set_num_threads(n).

Если ключевой аргумент parallel установлен в true, peakflops выполняется параллельно на всех процессорах. Возвращается скорость выполнения операций на всем параллельном компьютере. При выполнении в параллельном режиме используется только 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 = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

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

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

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

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 = UpperTriangular([1 2; 0 3]);

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

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

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

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

get_num_threads()

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

rot!(n, X, incx, Y, incy, c, s)

Перезаписывает X значением c*X + s*Y и Y значением -conj(s)*X + c*Y для первых n элементов массива X с шагом incx и первых n элементов массива Y с шагом incy. Возвращает X и Y.

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) соответственно.

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

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

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

nrm2(n, X, incx)

2-норма вектора, состоящего из n элементов массива X с шагом incx.

Примеры

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

Сумма модулей первых n элементов массива X с шагом incx.

Для вещественного массива модуль — это абсолютное значение. Для комплексного массива модуль — это сумма абсолютных значений вещественной и мнимой частей.

Примеры

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

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

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

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.

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 — скаляр.

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.

hpmv!(uplo, α, AP, x, β, y)

Обновить вектор y как α*A*x + β*y, где A — это эрмитова матрица, предоставленная в упакованном формате AP.

С uplo = 'U' массив AP должен содержать верхнюю треугольную часть эрмитовой матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

С uplo = 'L' массив AP должен содержать нижнюю треугольную часть эрмитовой матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярные входные данные α и β должны быть комплексными или вещественными числами.

Массивные входные данные x, y и AP должны быть всех типа ComplexF32 или ComplexF64.

Возвратить обновлённый y.

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.

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

Обновить вектор y как alpha*A*x + beta*y, где A — симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Макет хранения для A описан в справочном модуле BLAS, BLAS 2 уровня, в 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.

spmv!(uplo, α, AP, x, β, y)

Обновить вектор y как α*A*x + β*y, где A — симметричная матрица, предоставленная в упакованном формате AP.

С uplo = 'U' массив AP должен содержать верхнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

С uplo = 'L' массив AP должен содержать нижнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярные входные данные α и β должны быть вещественными.

Массивные входные данные x, y и AP должны быть всех типа Float32 или Float64.

Возвратить обновлённый y.

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 определяет, читаются ли значения диагонали, или предполагается, что они все равны единице.

ger!(alpha, x, y, A)

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

her!(uplo, alpha, x, A)

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

syr!(uplo, alpha, x, A)

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

spr!(uplo, α, x, AP)

Обновить матрицу A как A+α*x*x', где A — симметричная матрица, предоставленная в упакованном формате AP, и x — вектор.

С uplo = 'U' массив AP должен содержать верхнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

С uplo = 'L' массив AP должен содержать нижнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярный входной параметр α должен быть вещественным.

Массивные входные данные x и AP должны быть всех типа Float32 или Float64. Возвратить обновлённый AP.

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.

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.

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.

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

Обновление ранга-k симметричной матрицы C как 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.

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

Методы только для комплексных массивов. Обновление ранга-k эрмитовой матрицы C как 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.

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

Обновление ранга-2k симметричной матрицы C как 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.

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

Обновление ранга-2k эрмитовой матрицы C как 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.

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 определяет, читаются ли диагональные значения или предполагаются равными единице.

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

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

Вычислить LU-разложение полосовой матрицы AB. ku — это первый побочный диагональ, содержащий ненулевую полосу, 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)

Вычислить pivoted QR разложение A, AP = QR, используя BLAS уровня 3. P — это матрица поворота, представленная jpvt. tau хранит элементарные отражатели. Аргументы jpvt и tau необязательны и позволяют передавать предварительно выделенные массивы. При передаче jpvt должен иметь длину, большую или равную n, если A является (m x n) матрицей, и 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 слева или справа, в зависимости от 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 факторизацию A. A перезаписывается с её LU факторизацией, а B перезаписывается с решением X. ipiv содержит информацию о поворотах для 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 из факторизации QR матрицы 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 = 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, то условное число ищется в норме 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.