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

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

Примеры

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

SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

dot(x, y)
x ⋅ y

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

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

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

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

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

Создаёт матрицу из диагонали A.

Примеры

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> Diagonal(A)
3×3 Diagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅
 ⋅  5  ⋅
 ⋅  ⋅  9

Diagonal(V::AbstractVector)

Создаёт матрицу с V в качестве её диагонали.

Примеры

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

julia> Diagonal(V)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  2

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

Создаёт верхнюю (uplo=:U) или нижнюю (uplo=:L) бидиагональную матрицу, используя заданные диагональные (dv) и внедиагональные (ev) векторы. Результат является типа Bidiagonal и предоставляет эффективные специализированные линейные решатели, но может быть преобразован в обычную матрицу с помощью convert(Array, _) (или Array(_) для краткости). Длина ev должна быть на единицу меньше длины dv.

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

Постройте симметричную трехдиагональную матрицу из диагонали и первой наддиагонали симметричной матрицы A.

Примеры

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

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅
 2  4  5
 ⋅  5  6

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

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

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

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

Примеры

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

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

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

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

Tridiagonal(A)

Постройте трехдиагональную матрицу из первой поддиагонали, диагонали и первой наддиагонали матрицы A.

Примеры

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

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

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

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

LowerTriangular(A::AbstractMatrix)

Постройте LowerTriangular представление матрицы A.

Примеры

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

julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  5.0   ⋅
 7.0  8.0  9.0

UpperTriangular(A::AbstractMatrix)

Постройте UpperTriangular представление матрицы A.

Примеры

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

julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   5.0  6.0
  ⋅    ⋅   9.0

UnitLowerTriangular(A::AbstractMatrix)

Постройте UnitLowerTriangular представление матрицы A. Такое представление имеет единицу oneunit типа eltype A на своей диагонали.

Примеры

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

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0

UnitUpperTriangular(A::AbstractMatrix)

Постройте UnitUpperTriangular представление матрицы A. Такое представление имеет единицу oneunit типа eltype A на своей диагонали.

Примеры

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

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0

UpperHessenberg(A::AbstractMatrix)

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

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

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

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

Итерация по разложению производит факторы F.Q и F.H.

Примеры

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

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

UniformScaling{T<:Number}

Универсальный оператор равномерного масштабирования, определенный как скаляр, умноженный на оператор единицы, λ*I. Хотя без явного size, он действует подобно матрице во многих случаях и включает поддержку индексирования. См. также I.

Примеры

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

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

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

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

Примеры

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

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

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

Постройте матрицу Diagonal из UniformScaling.

Примеры

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

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

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

LU <: Factorization

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

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

Итерация по факторизации приводит к компонентам F.L, F.U и F.p.

Примеры

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

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

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

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

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

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

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

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

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

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

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

• \
• cond
• det

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

Вычисление LU-факторизации A.

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

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

Индивидуальные компоненты факторизации 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}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

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

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

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

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

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

Примеры

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

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

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

Итерация разложения порождает компоненты 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(_, Val(true)), соответствующей функции разложения матрицы.

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

Итерация разложения порождает компоненты 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, Val(true))
CholeskyPivoted{Float64, Matrix{Float64}}
U factor with rank 3:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 9.89949  -4.34366  -1.61624
  ⋅        4.25825   1.1694
  ⋅         ⋅        0.142334
permutation:
3-element Vector{Int64}:
 3
 2
 1

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

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

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

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

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

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

Примеры

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

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

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

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

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

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

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

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

julia> L = sparse(C.L);

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

julia> L * L' ≈ A
true

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

Вычисление разложения Холецкого плотной симметричной положительно определённой матрицы A и возвращение разложения Cholesky. Матрица A может быть Symmetric или Hermitian StridedMatrix, или совершенно симметричной или эрмитовой StridedMatrix. Треугольный фактор Холецкого можно получить из разложения F с помощью: F.L и F.U. Для объектов 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, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

Вычисление разложения Холецкого с выбором опорных элементов плотной симметричной полуположительно определённой матрицы A и возвращение разложения CholeskyPivoted. Матрица A может быть Symmetric или Hermitian StridedMatrix, или совершенно симметричной или эрмитовой StridedMatrix. Треугольный фактор Холецкого можно получить из разложения F с помощью: F.L и F.U. Для объектов CholeskyPivoted доступны следующие функции: size, \, inv, det и rank. Аргумент tol определяет пороговое значение для определения ранга. Для отрицательных значений порог равен машинной точности.

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

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

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

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

См. также cholesky.

cholesky!(A::StridedMatrix, Val(false); 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::StridedMatrix, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

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

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

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

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

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

lowrankupdate!(C::Cholesky, v::StridedVector) -> CC::Cholesky

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

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

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

LDLt <: Factorization

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

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

Примеры

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

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

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

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

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

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

ldlt(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt(S);

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

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

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

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

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

См. также ldlt.

ldlt!(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

QR <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

QRCompactWY <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

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

QRPivoted <: Factorization

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

\[A P = Q R\]

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

\[A = Q R\]

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

• если pivot == Val(true), то 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*Matrix(I,m,m). Если m<=n, то Matrix(F.Q) даст ортогональную матрицу m×m.

Размер блока для QR-разложения может быть задан ключевым аргументом blocksize :: Integer при pivot == Val(false) и 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}}
Q factor:
3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}}:
 -0.6   0.0   0.8
 -0.8   0.0  -0.6
  0.0  -1.0   0.0
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

qr!(A, pivot=Val(false); blocksize)

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

Примеры

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

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}}
Q factor:
2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}}:
 -0.316228  -0.948683
 -0.948683   0.316228
R factor:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

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

julia> qr!(a)
ERROR: InexactError: Int64(-3.1622776601683795)
Stacktrace:
[...]

LQ <: Factorization

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

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

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

Примеры

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}} with factors L and Q:
[-8.60233 0.0; 4.41741 -0.697486]
[-0.581238 -0.813733; -0.813733 0.581238]

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

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

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

lq(A) -> S::LQ

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

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

LQ-разложение — это QR-разложение transpose(A), и оно полезно для вычисления решения lq(A) \ b с минимальной нормой для недоопределённой системы уравнений (A имеет больше столбцов, чем строк, но имеет полный ранг строк).

Примеры

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}} with factors L and Q:
[-8.60233 0.0; 4.41741 -0.697486]
[-0.581238 -0.813733; -0.813733 0.581238]

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

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

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

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}}
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}}
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 ложно, поворот по правилам шахматной ладьи не используется.

Когда 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}}
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}}
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) -> BunchKaufman

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

Eigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B) -> GeneralizedEigen

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

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

Любые ключевые аргументы, переданные в eigen, передаются в низкоуровневую функцию eigen!.

Примеры

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, [B]; permute, scale, sortby)

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

Hessenberg <: Factorization

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

hessenberg(A) -> Hessenberg

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

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

Обратите внимание, что сдвинутую факторизацию A+μI = Q (H+μI) Q' можно эффективно построить с помощью F + μ*I, используя объект UniformScaling I, который создаёт новый объект Hessenberg с совместным хранилищем и изменённым сдвигом. Сдвиг заданного F получается с помощью F.μ. Это полезно, так как несколько сдвинутых решений (F + μ*I) \ b (для различных μ и/или b) можно эффективно выполнить после создания F.

Итерация разложения производит факторы F.Q, F.H, F.μ.

Примеры

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

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor:
3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}:
 1.0   0.0        0.0
 0.0  -0.707107  -0.707107
 0.0  -0.707107   0.707107
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # destructuring via iteration

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> Hessenberg

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

Schur <: Factorization

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

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

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

Примеры

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}}
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::StridedMatrix) -> F::Schur

Вычисляет разложение Шура матрицы A. (Квази)треугольный фактор Шура можно получить из объекта Schur F с помощью 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}}
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::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

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

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

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

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

Примеры

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}}
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}}
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}}
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 SparseArrays.SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 0.707107   ⋅
  ⋅        0.707107
D2 factor:
2×2 SparseArrays.SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 0.707107   ⋅
  ⋅        0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

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

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

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

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

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

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

Примеры

julia> A = rand(4,3);

julia> F = svd(A); # Store the Factorization Object

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # destructuring via iteration

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # Store U only

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Вычислить обобщенное сингулярное разложение A и B, возвращая объект разложения 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, как в геномах человека и дрожжей, или сигнала и шума, или между кластерами и внутри кластеров. (См. обсуждение в работах Edelman и Wang: https://arxiv.org/abs/1901.00485)

Он разлагает [A; B] на [UC; VS]H, где [UC; VS] — естественный ортогональный базис для столбцов [A; B], и H = RQ' — естественный неортогональный базис для строк [A;B], где верхние строки в большей степени связаны с матрицей A, а нижние — с матрицей B. Многокосинусные/многосинусные матрицы C и S предоставляют многомерную меру того, сколько A по сравнению с B, а U и V предоставляют направления, в которых это измеряется.

Примеры

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

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

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

svd!(A, B) -> GeneralizedSVD

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

svdvals(A)

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

Примеры

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

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

svdvals(A, B)

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

Примеры

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

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

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

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

svdvals!(A, B)

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

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

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

См. также: givens

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

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

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

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

y = G*x

имеет свойство

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

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

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

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

B = G*A

имеет свойство

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

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

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

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

B = G*x

имеет свойство

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

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

triu(M)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

Верхняя треугольная часть матрицы, перезаписывая M в процессе. См. также triu.

triu!(M, k::Integer)

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

Примеры

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

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

Нижняя треугольная часть матрицы, перезаписывая M в процессе. См. также tril.

tril!(M, k::Integer)

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

Примеры

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

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M, k::Integer=0)

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

Примеры

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

Примеры

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 в качестве первых аргументов.

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

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

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

Примеры

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

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

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

Примеры

julia> rank(Matrix(I, 3, 3))
3

julia> rank(diagm(0 => [1, 0, 2]))
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1

norm(A, p::Real=2)

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

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

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

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

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

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

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

Примеры

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

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

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

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

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

Для чисел верните $\left( |x|^p \right)^{1/p}$.

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

Вычислить операторную норму (или матричную норму), индуцированную векторной нормой p, где допустимые значения p — это 1, 2 или Inf. (Обратите внимание, что для разреженных матриц p=2 в настоящее время не реализовано.) Используйте norm для вычисления нормы Фробениуса.

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

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

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

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

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

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

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

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

Разница в норме между пространством векторов и его двойственным пространством возникает для сохранения взаимосвязи между двойственностью и скалярным произведением, и результат согласован с операторной нормой p матрицы 1 × n.

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

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

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

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

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

Примеры

julia> a = [1,2,4];

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

cond(M, p::Real=2)

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

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

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

Число обусловленности 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)

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

Примеры

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

Вычисляет псевдообратное Moore-Penrose.

Для матриц M с плавающей точкой удобно вычислить псевдообратное, обратив только сингулярные значения, большие, чем max(atol, rtol*σ₁), где σ₁ — наибольшее сингулярное значение M.

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

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

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

Примеры

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0

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

По умолчанию относительная толерантность rtol равна n*ϵ, где n — размер наименьшего измерения M, а ϵ — eps типа элемента M.

Примеры

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

julia> nullspace(M)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

julia> nullspace(M, rtol=3)
3×3 Matrix{Float64}:
 0.0  1.0  0.0
 1.0  0.0  0.0
 0.0  0.0  1.0

julia> nullspace(M, atol=0.95)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

kron(A, B)

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

Для векторов v и w, тензорное произведение Кронекера связано с внешним произведением соотношениями kron(v,w) == vec(w * transpose(v)) или w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). Обратите внимание, как порядок v и w отличается слева и справа в этих выражениях (из-за хранения в формате «столбец-перед-строкой»). Для комплексных векторов внешнее произведение w * v' также отличается конъюгацией v.

Примеры

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

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

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

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

exp(A::AbstractMatrix)

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

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

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

Примеры

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

^(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{T}::StridedMatrix{T})

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

Если A является симметричной или эрмитовой, используется её собственное разложение (eigen), если A треугольная, используется улучшенная версия алгоритма обратного масштабирования и возведения в квадрат (см. ^[AH12] и ^[AHR13]). Для общих матриц вычисляется комплексная форма Шура (schur), и алгоритм для треугольных матриц применяется к треугольному фактору.

Примеры

julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(A::AbstractMatrix)

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

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

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

Примеры

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

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

cos(A::AbstractMatrix)

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

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

Примеры

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

sin(A::AbstractMatrix)

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

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

Примеры

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

sincos(A::AbstractMatrix)

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

Примеры

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

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

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

tan(A::AbstractMatrix)

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

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

Примеры

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

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

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

asin(A::AbstractMatrix)

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

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

Примеры

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

atan(A::AbstractMatrix)

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

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

Примеры

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

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

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

Примеры

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

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

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

julia> A*X + X*A' + B
2×2 Matrix{Float64}:
 0.0          6.66134e-16
 6.66134e-16  8.88178e-16

sylvester(A, B, C)

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

Примеры

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

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

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

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

julia> A*X + X*B + C
2×2 Matrix{Float64}:
  2.66454e-15  1.77636e-15
 -3.77476e-15  4.44089e-16

issuccess(F::Factorization)

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

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

julia> LinearAlgebra.issuccess(F)
true

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

julia> LinearAlgebra.issuccess(F)
false

issymmetric(A) -> Bool

Проверка, является ли матрица симметричной.

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

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

Примеры

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

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

Примеры

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

julia> isposdef!(A)
true

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

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

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

Примеры

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(b)
true

julia> istril(b, -1)
false

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

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

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(b)
true

julia> istriu(b, 1)
false

isdiag(A) -> Bool

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

Леничная транспозиция. Изменение возвращаемого объекта должно соответствующим образом изменять A. Часто, но не всегда, возвращает Transpose(A), где Transpose — это обертка для леничной транспозиции. Обратите внимание, что эта операция рекурсивна.

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

Примеры

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

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

transpose!(dest,src)

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

Примеры

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

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

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

Transpose

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

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

Примеры

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

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

A'
adjoint(A)

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

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

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

Примеры

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

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

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

julia> x'x
25 + 0im

adjoint!(dest,src)

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

Примеры

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

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

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

Adjoint

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

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

Примеры

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

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

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

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

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

Примеры

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

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

Возвращает расстояние между последовательными элементами массива в измерении 1 в единицах размера элемента.

Примеры

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

Проверяет, является ли матрица квадратной, затем возвращает её общую размерность. Для нескольких аргументов возвращает вектор.

Примеры

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=2000; parallel::Bool=false)

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

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

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

Вычисляет произведение матрицы-матрицы или матрицы-вектора $AB$ и сохраняет результат в Y, перезаписывая существующее значение Y. Обратите внимание, что Y не должно быть алиасом ни A, ни B.

Примеры

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); mul!(Y, A, B);

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

Реализация

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

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

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

Примеры

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

julia> mul!(C, A, B, 100.0, 10.0) === C
true

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

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

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

Примеры

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

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

julia> Y = zero(X);

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

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

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

ldiv!(A, B)

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

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

Примеры

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

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

julia> Y = copy(X);

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

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

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

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

Разделить каждый элемент в массиве B на скаляр a, перезаписывая B на месте. Используйте rdiv! для деления скаляра справа.

Примеры

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

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

rdiv!(A, B)

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

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

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

Разделить каждый элемент в массиве A на скаляр b, перезаписывая A на месте. Используйте ldiv! для деления скаляра слева.

Примеры

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

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

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

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

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

Примеры

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

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

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

Примеры

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

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

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

Примеры

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

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

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

nrm2(n, X, incx)

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

Примеры

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

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

asum(n, X, incx)

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

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

Примеры

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

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

axpy!(a, X, Y)

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

Примеры

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

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

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

axpby!(a, X, b, Y)

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

Примеры

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

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

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

scal!(n, a, X, incx)

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

scal(n, a, X, incx)

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

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

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

ger!(alpha, x, y, A)

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

syr!(uplo, alpha, x, A)

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

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

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

syrk(uplo, trans, alpha, A)

Возвращает верхнюю или нижнюю треугольную часть A в зависимости от uplo, для alpha*A*transpose(A) или alpha*transpose(A)*A, в зависимости от trans.

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

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

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

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

syr2k(uplo, trans, A, B)

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

her!(uplo, alpha, x, A)

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

her2k(uplo, trans, A, B)

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

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

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

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

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

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

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

Вернуть обновлённый вектор y.

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

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

sbmv(uplo, k, A, x)

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

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

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

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

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

gemm(tA, tB, A, B)

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

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

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

gemv(tA, alpha, A, x)

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

gemv(tA, A, x)

Вернуть A*x или A'x в соответствии с tA.

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

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

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

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

symm(side, ul, A, B)

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

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

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

symv(ul, alpha, A, x)

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

symv(ul, A, x)

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

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

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

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

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

hemm(side, ul, A, B)

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

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

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

hemv(ul, alpha, A, x)

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

hemv(ul, A, x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

На экзотических вариантах BLAS, nothing может быть возвращено get_num_threads(). Таким образом, на экзотических вариантах BLAS следующая схема может не установить количество потоков:

old = get_num_threads()
set_num_threads(1)
@threads for i in 1:10
    # single-threaded BLAS calls
end
set_num_threads(old)

Так как set_num_threads принимает nothing, этот код всё ещё может работать на экзотических вариантах BLAS без ошибок. Вместо этого будут выводиться предупреждения.

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

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

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

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

Вычислить пивотную QR факторизацию A, AP = QR, используя 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 слева или справа от преобразования, заданного tzrzf!. В зависимости от side или trans умножение может быть слева (side = L, Q*C) или справа (side = R, C*Q), а Q может быть неизменённой (trans = N), транспонированной (trans = T) или сопряжённо-транспонированной (trans = C). Возвращает матрицу C, которая изменяется на месте с результатом умножения.

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

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

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

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

getrs!(trans, A, ipiv, B)

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

getri!(A, ipiv)

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

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

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

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

gesvx!(A, B)

Упрощенная версия gesvx! без балансировки и транспонирования.

gelsd!(A, B, rcond) -> (B, rnk)

Вычисляет решение с наименьшей нормой для A * X = B, найдя факторизацию SVD матрицы A, а затем решив задачу методом «разделяй и властвуй». Матрица B перезаписывается решением X. Сингулярные значения, меньшие чем rcond, будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gelsy!(A, B, rcond) -> (B, rnk)

Вычисляет решение с наименьшей нормой для A * X = B, найдя полную факторизацию QR матрицы A, а затем решив задачу методом «разделяй и властвуй». Матрица B перезаписывается решением X. Сингулярные значения, меньшие чем rcond, будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gglse!(A, c, B, d) -> (X,res)

Решает уравнение A * x = c, где x удовлетворяет условию равенства B * x = d. Использует формулу ||c - A*x||^2 = 0 для решения. Возвращает X и остаточную сумму квадратов.

geev!(jobvl, jobvr, A) -> (W, VL, VR)

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

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

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

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

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

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

ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

Находит обобщённое сингулярное разложение для матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. Матрица D1 имеет alpha на диагонали, а D2 имеет beta на диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq не требуется, эта матрица не вычисляется. Данная функция доступна только в версиях 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, соответствующие собственные векторы вычисляются.

gtsv!(dl, d, du, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

potrf!(uplo, A)

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

potri!(uplo, A)

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

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

potrs!(uplo, A, B)

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

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

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

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

ptsv!(D, E, B)

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

pttrf!(D, E)

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

pttrs!(D, E, B)

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

trtri!(uplo, diag, A)

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sytri!(uplo, A, ipiv)

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

sytrs!(uplo, A, ipiv, B)

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

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

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

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

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

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

hetri!(uplo, A, ipiv)

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

hetrs!(uplo, A, ipiv, B)

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

syev!(jobz, uplo, A)

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

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

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

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

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

Находит обобщенные собственные значения (jobz = N) или собственные значения и векторы (jobz = V) симметричной матрицы A и симметричной положительно определенной матрицы B. Если uplo = U, используются верхние треугольные части A и B. Если uplo = L, используются нижние треугольные части A и B. Если itype = 1, решаемая задача — A * x = lambda * B * x. Если itype = 2, решаемая задача — A * B * x = lambda * x. Если itype = 3, решаемая задача — B * A * x = lambda * x.

bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на внедиагональных элементах. Если uplo = U, e_ — это наддиагональ. Если uplo = L, e_ — это поддиагональ. Можно также вычислить произведение Q' * C.

Возвращает сингулярные значения в d, а матрицу C перезаписывает с Q' * C.

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на внедиагональных элементах, используя метод «разделяй и властвуй». Если uplo = U, e_ — это наддиагональ. Если uplo = L, e_ — это поддиагональ. Если compq = N, находятся только сингулярные значения. Если compq = I, находятся сингулярные значения и векторы. Если compq = P, сингулярные значения и векторы находятся в компактной форме. Работает только для вещественных типов.

Возвращает сингулярные значения в d, и если compq = P, компактные сингулярные векторы в iq.

gecon!(normtype, A, anorm)

Находит обратную величину условного числа матрицы A. Если normtype = I, условное число находится в бесконечной норме. Если normtype = O или 1, условное число находится в норме 1. A должно быть результатом getrf!, и anorm — нормой A в соответствующей норме.

gehrd!(ilo, ihi, A) -> (A, tau)

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

orghr!(ilo, ihi, A, tau)

Явно находит Q, ортогональную/унитарную матрицу из gehrd!. ilo, ihi, A и tau должны соответствовать входным/выходным данным для gehrd!.

gees!(jobvs, A) -> (A, vs, w)

Вычисляет собственные значения (jobvs = N) или собственные значения и шурские векторы (jobvs = V) матрицы A. A перезаписывается своей шурской формой.

Возвращает A, vs, содержащие шурские векторы, и w, содержащие собственные значения.

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

Вычисляет обобщенные собственные значения, обобщенную шурскую форму, левые шурские векторы (jobsvl = V) или правые шурские векторы (jobvsr = V) матриц A и B.

Обобщенные собственные значения возвращаются в alpha и beta. Левые шурские векторы возвращаются в vsl, а правые шурские векторы — в vsr.

trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)

Переупорядочивает шурское разложение T матрицы таким образом, чтобы диагональный блок T с индексом строки ifst переместился в строку с индексом ilst. Если compq = V, шурские векторы Q переупорядочиваются. Если compq = N, они не изменяются. Метод с 4 аргументами вызывает метод с 5 аргументами, используя compq = V.

trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)

Переупорядочивает шурское разложение матрицы и необязательно находит обратные числа обусловленности. Если job = N, числа обусловленности не находятся. Если job = E, находится только число обусловленности для данного кластера собственных значений. Если job = V, находится только число обусловленности для инвариантного подпространства. Если job = B, находятся числа обусловленности для кластера и подпространства. Если compq = V, шурские векторы Q обновляются. Если compq = N, шурские векторы не изменяются. select определяет, какие собственные значения находятся в кластере. Метод с 3 аргументами вызывает метод с 5 аргументами, используя job = N и compq = V.

Возвращает T, Q, переупорядоченные собственные значения в w, число обусловленности кластера собственных значений s и число обусловленности инвариантного подпространства sep.

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщенного шурского разложения. select задаёт собственные значения в каждом кластере.

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

Решает уравнение Сильвестра A * X +/- X * B = scale*C, где A и B являются квазиверхнетреугольными. Если transa = N, A не изменяется. Если transa = T, A транспонируется. Если transa = C, A сопряжено транспонируется. Аналогично для transb и B. Если isgn = 1, решается уравнение A * X + X * B = scale * C. Если isgn = -1, решается уравнение A * X - X * B = scale * C.

Возвращает X (перезаписывая C) и scale.