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

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

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

Примеры

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

\(A, B)

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

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

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

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

Примеры

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

julia> X = A \ B
2-element Vector{Float64}:
 32.0
 18.0

julia> A * X == B
true

SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

dot(x, y)
x ⋅ y

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

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

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

x ⋅ y (где ⋅ можно ввести, нажав Tab в REPL, когда \cdot), является синонимом dot(x, y).

Примеры

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

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

julia> dot(1:5, 2:6)
70

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

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

julia> dot(x, y)
150.0

dot(x, A, y)

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

Примеры

julia> dot([1; 1], [1 2; 3 4], [2; 3])
26

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true

cross(x, y)
×(x,y)

Вычисляет векторное произведение двух 3-векторов.

Примеры

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

factorize(A)

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

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

Примеры

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorize(A) # factorize will check to see that A is already factorized
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

Это возвращает 5×5 Bidiagonal{Float64}, которая теперь может передаваться в другие функции линейной алгебры (например, решатели собственных значений), которые будут использовать специализированные методы для типов Bidiagonal.

Diagonal(V::AbstractVector)

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

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

Примеры

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

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

Diagonal(A::AbstractMatrix)

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

Примеры

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

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

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

Diagonal{T}(undef, n)

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

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

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

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

Tridiagonal(A)

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

Примеры

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

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

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

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

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

LowerTriangular(A::AbstractMatrix)

Создаёт LowerTriangular вид матрицы A.

Примеры

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

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

UpperTriangular(A::AbstractMatrix)

Создаёт UpperTriangular вид матрицы A.

Примеры

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

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

UnitLowerTriangular(A::AbstractMatrix)

Создаёт UnitLowerTriangular вид матрицы A. Такой вид имеет oneunit eltype A на своей диагонали.

Примеры

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

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

UnitUpperTriangular(A::AbstractMatrix)

Создаёт UnitUpperTriangular вид матрицы A. Такой вид имеет oneunit eltype A на своей диагонали.

Примеры

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

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

UpperHessenberg(A::AbstractMatrix)

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

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

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

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

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

Примеры

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

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

UniformScaling{T<:Number}

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

Примеры

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

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

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

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

I

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

Примеры

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

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

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

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

Примеры

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

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

LinearAlgebra.Factorization

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

LU <: Factorization

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

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

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

Примеры

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}}
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, pivot = RowMaximum(); check = true) -> F::LU

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

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

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

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

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

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

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

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

Примеры

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}}
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 = RowMaximum(); check = true) -> LU

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

Примеры

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

julia> F = lu!(A)
LU{Float64, Matrix{Float64}}
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:
[...]

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

Cholesky <: Factorization

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

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

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

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

Примеры

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

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

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

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

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

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

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

CholeskyPivoted

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

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

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

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

Примеры

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

julia> A = X * X';

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> A = X * X';

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

julia> L = sparse(C.L);

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

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

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

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

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

julia> L = sparse(C.L);

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

julia> L * L' ≈ A
true

cholesky!(A::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, например, для целых типов.

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

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

См. также cholesky.

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

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

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

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

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

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

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

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

LDLt <: Factorization

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

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

Примеры

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

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

ldlt(S::SymTridiagonal) -> LDLt

Вычислить LDLt факторизацию вещественной симметричной тридиагональной матрицы 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(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

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

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

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

ldlt!(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

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

См. также ldlt.

QR <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

QRCompactWY <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

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

QRPivoted <: Factorization

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

\[A P = Q R\]

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

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

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

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

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

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

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

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

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

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

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

\[A = Q R\]

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

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

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

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

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

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

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

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

Разрешено умножение как на полных/квадратных, так и на неполных/прямоугольных матрицах 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 == NoPivot() и A isa StridedMatrix{<:BlasFloat}. Он игнорируется при использовании blocksize > minimum(size(A)). См. QRCompactWY.

Примеры

julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
 3.0  -6.0
 4.0  -8.0
 0.0   1.0

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}}
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::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

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

Примеры

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

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

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

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

Примеры

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

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}}
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}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor:
2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

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

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

lq(A) -> S::LQ

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

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

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

Примеры

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

julia> S = lq(A)
LQ{Float64, Matrix{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor:
2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

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

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

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}}
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.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

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

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

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

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

Eigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B) -> 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
   ⋅        -1.0444e-15   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.

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

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

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

diag(M, k::Integer=0)

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

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

Примеры

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

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

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

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

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)

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

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

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

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

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

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

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

cond(M, p::Real=2)

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

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

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

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

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

tr(M)

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

Примеры

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

julia> tr(A)
5

det(M)

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

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

Примеры

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

julia> det(M)
2.0

logdet(M)

Логарифм определителя матрицы. Эквивалентно log(det(M)), но может обеспечить повышенную точность и/или скорость.

Примеры

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

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

Логарифм абсолютного значения определителя матрицы. Эквивалентно (log(abs(det(M))), sign(det(M))), но может обеспечить повышенную точность и/или скорость.

Примеры

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

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

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

Примеры

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

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

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

Вычисляет псевдообратное 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

cis(A::AbstractMatrix)

Вычислить $\exp(i A)$ для квадратной матрицы $A$.

Примеры

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

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

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

Примеры

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

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

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

Примеры

julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::StridedMatrix)

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

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

Примеры

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

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

sqrt(A::AbstractMatrix)

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

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

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

Примеры

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

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

cos(A::AbstractMatrix)

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

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

Примеры

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

sin(A::AbstractMatrix)

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

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

Примеры

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

sincos(A::AbstractMatrix)

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

Примеры

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

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

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

tan(A::AbstractMatrix)

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

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

Примеры

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

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

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

asin(A::AbstractMatrix)

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

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

Примеры

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

atan(A::AbstractMatrix)

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

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

Примеры

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

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

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

Примеры

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

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

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

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

sylvester(A, B, C)

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

Примеры

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

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

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

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

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

issuccess(F::Factorization)

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

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

julia> LinearAlgebra.issuccess(F)
true

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

julia> LinearAlgebra.issuccess(F)
false

issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

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

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

Примеры

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

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

Примеры

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

julia> isposdef!(A)
true

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

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

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

Примеры

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(b)
true

julia> istril(b, -1)
false

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

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

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(b)
true

julia> istriu(b, 1)
false

isdiag(A) -> Bool

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

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

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

Примеры

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

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

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

Transpose

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

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

Примеры

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

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

A'
adjoint(A)

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

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

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

Примеры

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

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

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

julia> x'x
25 + 0im

adjoint!(dest,src)

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

Примеры

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

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

julia> adjoint!(B, A);

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

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

Adjoint

Леничный оберточный тип для представления сопряжённого вида базового объекта линейной алгебры, обычно матрицы/вектора, но также и некоторых 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

Комбинированное "in-place" умножение-сложение матриц или матрицы на вектор $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 "in-place". Используйте 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 "in-place". Используйте 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.051652892561983806
  0.10020661157024781

julia> A\X
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198342
  0.1002066115702479

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.051652892561983806
  0.10020661157024781

julia> A\Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198342
  0.1002066115702479

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

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

Примеры

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

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

rdiv!(A, B)

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

Примеры

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

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

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

Примеры

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

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

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

nrm2(n, X, incx)

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

Примеры

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

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

asum(n, X, incx)

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

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

Примеры

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

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

axpy!(a, X, Y)

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

Примеры

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

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

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

axpby!(a, X, b, Y)

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

ger!(alpha, x, y, A)

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

syr!(uplo, alpha, x, A)

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

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

Обновление симметричной матрицы C по правилу ранга k как alpha*A*transpose(A) + beta*C или alpha*transpose(A)*A + beta*C в соответствии с trans. Используется только треугольная часть C, соответствующая uplo. Возвращает 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. Используется только треугольная часть C, соответствующая uplo. Возвращает C.

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

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

syr2k(uplo, trans, A, B)

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

her!(uplo, alpha, x, A)

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

her2k(uplo, trans, A, B)

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

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

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

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

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

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

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

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

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

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

sbmv(uplo, k, A, x)

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

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

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

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

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

gemm(tA, tB, A, B)

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

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

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

gemv(tA, alpha, A, x)

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

gemv(tA, A, x)

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

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

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

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

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

symm(side, ul, A, B)

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

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

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

symv(ul, alpha, A, x)

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

symv(ul, A, x)

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

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

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

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

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

hemm(side, ul, A, B)

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

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

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

hemv(ul, alpha, A, x)

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

hemv(ul, A, x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

get_num_threads()

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

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

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

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

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

Вычислите факторизацию QR с поворотом матрицы A, AP = QR, используя уровень 3 BLAS. P — матрица поворота, представленная как jpvt. tau хранит элементарные отражатели. Аргументы jpvt и tau необязательны и позволяют передавать предварительно выделенные массивы. При передаче, длина jpvt должна быть больше или равна n, если A — матрица (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 является N, эта матрица не вычисляется. Данная функция доступна только в версиях LAPACK до 3.6.0.

ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

Находит обобщённое сингулярное разложение матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. Матрица D1 имеет alpha на диагонали, а матрица D2 имеет beta на диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq является N, эта матрица не вычисляется. Данная функция требует LAPACK 3.6.0.

geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)

Находит собственную систему A с балансировкой матриц. Если jobvl = N, левые собственные векторы A не вычисляются. Если jobvr = N, правые собственные векторы A не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются. Если balanc = N, балансировка не выполняется. Если balanc = P, A переставляется, но не масштабируется. Если balanc = S, A масштабируется, но не переставляется. Если balanc = B, A переставляется и масштабируется. Если sense = N, обратные числа обусловленности не вычисляются. Если sense = E, обратные числа обусловленности вычисляются только для собственных значений. Если sense = V, обратные числа обусловленности вычисляются только для правых собственных векторов. Если sense = B, обратные числа обусловленности вычисляются для правых и левых собственных векторов. Если sense = E,B, правые и левые собственные векторы должны быть вычислены.

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

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

gtsv!(dl, d, du, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

potrf!(uplo, A)

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

potri!(uplo, A)

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

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

potrs!(uplo, A, B)

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

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

Вычисляет (верхнюю, если uplo = U, нижнюю, если uplo = L) факторизацию Холецкого с выбором опорных элементов (pivoting) положительно определенной матрицы 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. B перезаписывается решением X.

trtri!(uplo, diag, A)

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sytri!(uplo, A, ipiv)

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

sytrs!(uplo, A, ipiv, B)

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

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

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

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

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

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

hetri!(uplo, A, ipiv)

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

hetrs!(uplo, A, ipiv, B)

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

syev!(jobz, uplo, A)

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

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

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

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

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

Находит обобщенные собственные значения (jobz = N) или собственные значения и векторы (jobz = V) симметричной матрицы A и симметричной положительно определенной матрицы B. Если uplo = U, используются верхние треугольные части A и B. Если uplo = L, используются нижние треугольные части A и B. Если itype = 1, решаемая задача — A * x = lambda * B * x. Если itype = 2, решаемая задача — A * B * x = lambda * x. Если itype = 3, решаемая задача — B * A * x = lambda * x.

bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на побочной диагонали. Если uplo = U, e_ — это наддиагональ. Если uplo = L, e_ — это поддиагональ. Также можно вычислить произведение Q' * C.

Возвращает сингулярные значения в d, а матрицу C перезаписывает Q' * C.

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на побочной диагонали, используя метод «разделяй и властвуй». Если uplo = U, e_ — это наддиагональ. Если uplo = L, e_ — это поддиагональ. Если compq = N, находятся только сингулярные значения. Если compq = I, находятся сингулярные значения и векторы. Если compq = P, сингулярные значения и векторы находятся в компактной форме. Работает только для вещественных типов.

Возвращает сингулярные значения в d, а если compq = P, компактные сингулярные векторы в iq.

gecon!(normtype, A, anorm)

Находит обратную величину условного числа матрицы A. Если normtype = I, условное число находится в норме бесконечности. Если normtype = O или 1, условное число находится в норме единицы. A должно быть результатом вызова getrf!, а anorm — нормой A в соответствующей норме.

gehrd!(ilo, ihi, A) -> (A, tau)

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

orghr!(ilo, ihi, A, tau)

Явно находит Q, ортогональную/унитарную матрицу из gehrd!. ilo, ihi, A и tau должны соответствовать входным/выходным данным для gehrd!.

gees!(jobvs, A) -> (A, vs, w)

Вычисляет собственные значения (jobvs = N) или собственные значения и векторы Шюра (jobvs = V) матрицы A. A перезаписывается её формой Шюра.

Возвращает A, vs, содержащие векторы Шюра, и w, содержащие собственные значения.

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

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

Обобщенные собственные значения возвращаются в alpha и beta. Левые векторы Шюра возвращаются в vsl, а правые — в vsr.

trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)

Переупорядочивает факторизацию Шюра T матрицы таким образом, чтобы диагональный блок T с индексом строки ifst был перемещён в строку с индексом ilst. Если compq = V, векторы Шюра Q переупорядочиваются. Если compq = N, они не изменяются. Метод с 4 аргументами вызывает метод с 5 аргументами с использованием compq = V.

trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)

Переупорядочивает факторизацию Шюра матрицы и, необязательно, находит обратные числа обусловленности. Если job = N, числа обусловленности не находятся. Если job = E, находится только число обусловленности для этого кластера собственных значений. Если job = V, находится только число обусловленности для инвариантного подпространства. Если job = B, находят числа обусловленности для кластера и подпространства. Если compq = V, векторы Шюра Q обновляются. Если compq = N, векторы Шюра не изменяются. select определяет, какие собственные значения находятся в кластере. Метод с 3 аргументами вызывает метод с 5 аргументами с использованием job = N и compq = V.

Возвращает T, Q, переупорядоченные собственные значения в w, число обусловленности кластера собственных значений s и число обусловленности инвариантного подпространства sep.

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщенного разложения Шюра. select определяет собственные значения в каждом кластере.

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

Решает уравнение Сильвестра A * X +/- X * B = scale*C, где A и B являются квазиверхнетреугольными. Если transa = N, A не изменяется. Если transa = T, A транспонируется. Если transa = C, A сопряженно транспонируется. Точно так же для transb и B. Если isgn = 1, решается уравнение A * X + X * B = scale * C. Если isgn = -1, решается уравнение A * X - X * B = scale * C.

Возвращает X (перезаписывая C) и scale.