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

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

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

dot(x, y)
x ⋅ y

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

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

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

x ⋅ y (где ⋅ может быть введён, набрав \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 в качестве её диагонали.

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

Примеры

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

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

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

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

Обратите внимание, что матрица с одним столбцом не обрабатывается как вектор, а вместо этого вызывает метод Diagonal(A::AbstractMatrix), который извлекает 1-элементный diag(A):

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

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::AbstractMatrix, uplo::Symbol=:U)

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

Symmetric виды полезны в основном для вещественно-симметричных матриц, для которых специализированные алгоритмы (например, для задач собственных значений) включены для Symmetric типов. Более общо, см. также Hermitian(A) для эрмитовых матриц A == A', что эффективно эквивалентно Symmetric для вещественных матриц, но также полезно для комплексных матриц. (В то время как комплексные Symmetric матрицы поддерживаются, но имеют мало, если какие-либо специализированные алгоритмы.)

Чтобы вычислить симметричную часть вещественной матрицы или более общо эрмитовую часть (A + A') / 2 вещественной или комплексной матрицы A, используйте hermitianpart.

Примеры

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

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

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

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

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

Hermitian(A::AbstractMatrix, uplo::Symbol=:U)

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

Для вычисления эрмитовой части A используйте hermitianpart.

Примеры

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

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

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

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

Обратите внимание, что 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 по умолчанию соответствует конфигурации UMFPACK по умолчанию, но может быть изменён путём передачи вектора длины 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, NoPivot(); check = true) -> Cholesky

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

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

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

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

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

Примеры

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

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

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

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

Треугольный фактор Холецкого может быть получен из факторизации F через F.L и F.U, а перестановка через F.p, где A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' с Ur = F.U[1:F.rank, :] и Lr = F.L[:, 1:F.rank], или, как альтернатива, A ≈ Up' * Up ≈ Lp * Lp' с Up = F.U[1:F.rank, invperm(F.p)] и Lp = F.L[invperm(F.p), 1:F.rank].

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

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

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

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

Примеры

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

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

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

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

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

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

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

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

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

Примеры

В следующем примере используемая пермутация, уменьшающая заполнение, равна [3, 2, 1]. Если perm установлено в 1:3 для принудительного отсутствия перестановки, количество ненулевых элементов в факторе равно 6.

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

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

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, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

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

julia> L * L' ≈ A
true

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

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

Примеры

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

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

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

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

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

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

См. также cholesky.

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

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

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Получите факторизацию Холецкого LDLt A + C*C', заданную факторизацией LDLt или LLt F A.

Возвращаемый фактор всегда является факторизацией LDLt.

См. также lowrankupdate!, lowrankdowndate, lowrankdowndate!.

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

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Получите факторизацию LDLt факторизации A + C*C', заданной факторизацией LDLt или LLt факторизацией F матрицы A.

Возвращаемый фактор всегда является факторизацией LDLt.

См. также lowrankdowndate!, lowrankupdate, lowrankupdate!.

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 уничтожается во время вычисления.

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

Обновляет факторизацию LDLt или LLt факторизации F матрицы A до факторизации матрицы A + C*C'.

Факторизации LLt преобразуются в факторизации LDLt.

См. также lowrankupdate, lowrankdowndate, lowrankdowndate!.

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 уничтожается во время вычисления.

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

Обновляет факторизацию LDLt или LLt факторизации F матрицы A до факторизации матрицы A - C*C'.

Факторизации LLt преобразуются в факторизации LDLt.

См. также lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Factorization

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

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

Примеры

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

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

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

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

Примеры

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

julia> ldltS = ldlt(S);

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

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

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

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

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

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

ldlt!(S::SymTridiagonal) -> LDLt

То же, что и ldlt, но экономит память, перезаписывая входной S вместо создания копии.

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

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

См. также ldlt.

QR <: Factorization

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

\[A = Q R\]

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

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

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

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

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

  • В верхней треугольной части содержатся элементы $R$, то есть R = triu(F.factors) для объекта 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]. Основное применение этого типа — решение задач наименьших квадратов или недоопределённых задач с \. Функция вызывает библиотеку 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 или collect(F.Q). Если 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}}
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 является подтипом AbstractMatrix, но экономит память, перезаписывая входной 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}}
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}}

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

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # destructuring via iteration

julia> l == S.L &&  q == S.Q
true

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

julia> d == S.D && u == S.U && p == S.p
true

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

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

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

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

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

julia> d == S.D && u == S.U && p == S.p
true

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

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

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

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

Eigen <: Factorization

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

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

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

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

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

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

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

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

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

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

Примеры

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

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

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

Возвращает собственные значения матрицы A. Можно вычислить только подмножество собственных значений, указав UnitRange irange, охватывающий индексы отсортированных собственных значений, например, 2-е по 8-е собственные значения.

Примеры

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

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

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

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

Возвращает собственные значения матрицы A. Можно вычислить только подмножество собственных значений, указав пару vl и vu для нижней и верхней границ собственных значений.

Примеры

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

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

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

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

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

Примеры

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

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

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

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

Аналогично eigvals, но экономит память, перезаписывая входные матрицы A (и B) вместо создания копий.

Примеры

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

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

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

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

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

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

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

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

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

Если задан необязательный вектор собственных значений eigvals, eigvecs возвращает соответствующие собственные векторы.

Примеры

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

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

julia> eigvecs(A)
3×3 Matrix{Float64}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

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

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

Примеры

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

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

Примеры

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

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

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

Вычисляет разложение по собственным значениям матрицы A, возвращая объект разложения Eigen F, который содержит собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. Это соответствует решению задачи на собственные значения в форме Ax = λx, где A — матрица, x — собственный вектор, а λ — собственное значение. (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. Это соответствует решению обобщённой задачи на собственные значения вида Ax = λBx, где A, B — матрицы, x — собственный вектор, а λ — собственное значение. (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}
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

Вычислить обобщённое SVD матриц A и B, возвращая объект факторизации GeneralizedSVD F, такой что

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

Обобщённое SVD используется в приложениях, таких как сравнение того, сколько принадлежит A по сравнению с тем, сколько принадлежит B (например, геном человека против дрожжей, или сигнал против шума, или между кластерами против внутри кластеров). (См. обсуждение Эдельмана и Вэня: 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-й диагонали матрицы M.

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

Примеры

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

julia> diagind(A,-1)
2:4:6

diag(M, k::Integer=0)

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

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

Примеры

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

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

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

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

diagm строит полную матрицу; если вам нужны более эффективные по памяти версии с быстрыми арифметическими операциями, см. Diagonal, Bidiagonal, Tridiagonal и SymTridiagonal.

Примеры

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

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

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

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

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

Примеры

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

rank(::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)

Вычисление численного ранга матрицы путём подсчёта количества результатов svdvals(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}\]

Число обусловленности Skeel $\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.

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 для отрицательных аргументов Real. Используйте вместо этого комплексные отрицательные аргументы. Префиксный оператор √ эквивалентен 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*(max |λ|) обрабатываются как полуопределенные (что даёт эрмитов квадратный корень), а отрицательные собственные значения принимаются равными нулю. rtol — ключевой аргумент для sqrt (только в случае эрмитовых/вещественно-симметричных матриц), по умолчанию установленный в машинную точность, умноженную на size(A,1).

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

Примеры

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

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cos(A::AbstractMatrix)

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

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

Примеры

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

sin(A::AbstractMatrix)

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

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

Примеры

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

sincos(A::AbstractMatrix)

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

Примеры

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

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

tan(A::AbstractMatrix)

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

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

Примеры

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

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

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

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

Примеры

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

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

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

Примеры

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

Вычисляет решение X для непрерывного уравнения Ляпунова AX + XA' + C = 0, где ни один собственный корень A не имеет нулевой действительной части и ни две собственные пары не являются комплексно сопряжёнными с отрицательными значениями.

Примеры

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

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

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
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(F::Factorization)

Ленивое транспонирование факторизации F. По умолчанию возвращает TransposeFactorization, за исключением Factorization с действительными eltype, в этом случае возвращает AdjointFactorization.

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. Обычно, конструктор 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

TransposeFactorization

Ленивая оболочка для транспонированного представления базового объекта Factorization. Обычно, конструктор TransposeFactorization не должен вызываться напрямую, используйте transpose(:: Factorization) вместо этого.

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(F::Factorization)

Ленивая сопряжённая транспозиция факторизации F. По умолчанию, возвращает оболочку AdjointFactorization.

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. Обычно, конструктор 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

AdjointFactorization

Ленивая оболочка для сопряжённого представления базового объекта Factorization. Обычно, конструктор AdjointFactorization не должен вызываться напрямую, используйте adjoint(:: Factorization) вместо этого.

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=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

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

Если предоставлен ключевой аргумент eltype, peakflops создаст матрицы с элементами типа eltype для вычисления пиковой скорости выполнения операций.

По умолчанию peakflops будет использовать лучший результат из 3 испытаний. Если предоставлен ключевой аргумент ntrials, peakflops будет использовать указанное количество испытаний для выбора лучшего результата.

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

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Возвращает симметричную часть квадратной матрицы A, определённую как (A + A') / 2, как матрицу Hermitian. Для вещественных матриц A это также известно как симметричная часть A; иногда это также называют "вещественной частью оператора". Необязательный аргумент uplo управляет соответствующим аргументом представления Hermitian. Для вещественных матриц последнее эквивалентно представлению Symmetric.

См. также hermitianpart! для соответствующей операции на месте.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

На месте перезаписывает квадратную матрицу A её симметричной частью (A + A') / 2 и возвращает Hermitian(A, uplo). Для вещественных матриц A это также известно как симметричная часть A.

См. также hermitianpart для соответствующей операции вне места.

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 ≈ A\X
true

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 ≈ A\Y
true

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, уровень-2 BLAS по адресу http://www.netlib.org/lapack/explore-html/. Используется только uplo треугольник A.

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

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

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

sbmv(uplo, k, A, x)

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

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)

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

syrk(uplo, trans, alpha, A)

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

syr2k(uplo, trans, A, B)

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

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

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

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

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

her2k(uplo, trans, A, B)

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

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. kl — первая поддиагональ, содержащая ненулевой элемент, ku — последняя верхняя диагональ, содержащая единицу, а m — первая размерность матрицы AB. Возвращает LU-разложение на месте и ipiv, вектор используемых поворотов.

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

Вычисляет пивотную QR факторизацию A, AP = QR, используя 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. Матрица 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 не вычисляется. Эта функция доступна только в версиях 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 не вычисляется. Эта функция требует 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, соответствующие собственные векторы вычисляются.

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

Находит обобщённое разложение собственных векторов A и B, используя блочный алгоритм. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются. Эта функция требует LAPACK 3.6.0.

gtsv!(dl, d, du, B)

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

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

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

Находит факторизацию Холецкого треугольной матрицы с 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), используя факторизацию Холецкого, вычисленную функцией gttrf!. B перезаписывается решением X.

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

Явно находит матрицу Q факторизации QR после вызова 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) факторизацию Холецкого с выбором опор с заданной точностью tol для положительно определённой матрицы A. A перезаписывается факторизацией Холецкого.

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

ptsv!(D, E, B)

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

pttrf!(D, E)

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

pttrs!(D, E, B)

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

trtri!(uplo, diag, A)

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает A, перезаписываемое разложением, вектор поворотов ipiv и код ошибки info, который является неотрицательным целым числом. Если info положительно, матрица вырождена, и диагональная часть разложения равна точно нулю в позиции info.

sytri!(uplo, A, ipiv)

Вычисляет обратную матрицу симметричной матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, нижняя половина хранится. A перезаписывается своей обратной матрицей.

sytrs!(uplo, A, ipiv, B)

Решает уравнение A * X = B для симметричной матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, нижняя половина хранится. B перезаписывается решением X.

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

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

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

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

Возвращает A, перезаписываемое разложением, вектор поворотов ipiv и код ошибки info, который является неотрицательным целым числом. Если info положительно, матрица вырождена, и диагональная часть разложения равна точно нулю в позиции info.

hetri!(uplo, A, ipiv)

Вычисляет обратную матрицу эрмитовой матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, нижняя половина хранится. A перезаписывается своей обратной матрицей.

hetrs!(uplo, A, ipiv, B)

Решает уравнение A * X = B для эрмитовой матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, нижняя половина хранится. B перезаписывается решением X.

syev!(jobz, uplo, A)

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

syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)

Находит собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A. Если uplo = U, используется верхняя треугольная часть A. Если uplo = L, используется нижняя треугольная часть A. Если range = A, находятся все собственные значения. Если range = V, находятся собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, находятся собственные значения с индексами между il и iu. abstol может быть установлено как порог сходимости.

Собственные значения возвращаются в W, а собственные векторы — в Z.

syevd!(jobz, uplo, A)

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

Используется метод деления и завоевания, вместо итерации QR, используемой в syev! или нескольких относительно устойчивых представлений, используемых в syevr!. См. James W. Demmel et al, SIAM J. Sci. Comput. 30, 3, 1508 (2008) для сравнения точности и производительности различных методов.

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.

gges3!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)

Вычисляет обобщенные собственные значения, обобщенную форму Шюра, левые векторы Шюра (jobsvl = V) или правые векторы Шюра (jobvsr = V) для A и B, используя блочный алгоритм. Эта функция требует LAPACK 3.6.0.

Обобщенные собственные значения возвращаются в 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.

hseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)

Вычисляет все собственные значения и (по желанию) факторизацию Шюра матрицы, приведенной к эссенбергской форме. Если H сбалансирована с gebal!, то ilo и ihi являются результатами gebal!. В противном случае они должны быть ilo = 1 и ihi = size(H,2). tau содержит элементарные отражения факторизации.