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

NoPivot

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

RowNonZero

В качестве опорного элемента выбирается первый ненулевой элемент в оставшихся строках.

Обратите внимание, что для матриц с плавающей запятой полученный алгоритм LU является числово неустойчивым — эта стратегия в основном полезна для сравнения с ручными вычислениями (которые обычно используют эту стратегию) или для других алгебраических типов (например, рациональных чисел), не подверженных погрешностям округления. В противном случае, стратегия выбора опорного элемента по умолчанию RowMaximum должна быть предпочтительной при исключении Гаусса.

Обратите внимание, что тип элементов матрицы должен допускать метод iszero.

RowMaximum

В качестве опорного элемента выбирается элемент с максимальным модулем в оставшихся строках. Это стратегия по умолчанию для факторизации LU матриц с плавающей запятой и иногда называется алгоритмом «частичного выбора опорного элемента».

Обратите внимание, что тип элементов матрицы должен допускать метод abs, тип результата которого должен допускать метод <.

ColumnNorm

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

Обратите внимание, что тип элементов матрицы должен допускать методы norm и abs, типы результатов которых должны допускать метод <.

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

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

Примеры

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

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

Цепное умножение 3 или 4 матриц выполняется в наиболее эффективной последовательности на основе размеров массивов. То есть, количество скалярных умножений, необходимых для (A * B) * C (с 3 плотными матрицами), сравнивается с количеством для A * (B * C), чтобы выбрать, какой из них выполнить.

Если последний множитель является вектором или первый — транспонированным вектором, то эффективнее сначала обработать их. В частности, x' * B * y означает (x' * B) * y для обычной матрицы с хранением в порядке столбцов B::Matrix. В отличие от dot(x, B, y), это выделяет промежуточный массив.

Если первый или последний множитель — число, это будет объединённо с умножением матриц, используя 5-аргументный mul!.

См. также muladd, dot.

\(A, B)

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

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

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

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

Примеры

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

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

julia> A * X == B
true

A / B

Деление матриц справа: A / B эквивалентно (B' \ A')', где \ — оператор левого деления. Для квадратных матриц результат X такой, что A == X*B.

См. также: rdiv!.

Примеры

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

RankDeficientException

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

LAPACKException

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

dot(x, y)
x ⋅ y

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

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

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

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

Примеры

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

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

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

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

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

julia> dot(x, y)
150.0

dot(x, A, y)

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

rotate!(x, y, c, s)

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

reflect!(x, y, c, s)

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

factorize(A)

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

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

Примеры

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

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

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

Diagonal(V::AbstractVector)

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

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

Примеры

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

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

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

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

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

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

Diagonal(A::AbstractMatrix)

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

Примеры

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

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

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

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

Diagonal{T}(undef, n)

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

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

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

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

Tridiagonal(A)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

LowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

UpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

UnitLowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

UnitUpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

UpperHessenberg(A::AbstractMatrix)

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

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

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

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

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

Примеры

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

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

UniformScaling{T<:Number}

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

Примеры

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

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

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

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

I

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

Примеры

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

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

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

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

Примеры

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

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

LinearAlgebra.Factorization

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

LU <: Factorization

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

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

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

Примеры

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

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

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

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

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

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

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

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

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

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

Вектор control по умолчанию соответствует настройкам пакета Julia SparseArrays для UMFPACK (примечание: это изменено по сравнению с настройками UMFPACK, чтобы отключить итеративную уточнение), но может быть изменён путём передачи вектора длиной UMFPACK_CONTROL, см. руководство UMFPACK для возможных настроек. Например, чтобы снова включить итеративное уточнение:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # read Julia default configuration for a Float64 sparse matrix
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optional - display values
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # reenable iterative refinement (2 is UMFPACK default max iterative refinement steps)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # solve Ax = b, including UMFPACK iterative refinement

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

Взаимосвязь между F и A:

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

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

• \
• det

См. также lu!

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

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

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

По умолчанию, с check = true, также выбрасывается ошибка, если разложение генерирует корректные факторы, но верхнетреугольная матрица U является вырожденной по рангу. Это можно изменить путём передачи allowsingular = true.

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

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

• RowMaximum() (по умолчанию): стандартная стратегия пивотирования; опорный элемент соответствует элементу с максимальным абсолютным значением среди оставшихся строк для факторизации. Эта стратегия пивотирования требует, чтобы тип элементов также поддерживал abs и <. (Это, как правило, единственный численный стабильный вариант для матриц с плавающей точкой.)
• RowNonZero(): опорный элемент соответствует первому ненулевому элементу среди оставшихся строк для факторизации. (Это соответствует обычному выбору в ручных вычислениях и также полезно для более общих типов алгебраических чисел, которые поддерживают iszero, но не abs или <.)
• NoPivot(): пивотирование выключено (не сработает, если в позиции опорного элемента встретится нулевой элемент, даже когда allowsingular = true).

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

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

Взаимосвязь между F и A:

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

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

Примеры

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

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

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

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

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

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

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

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

См. также lu

Примеры

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

julia> F = lu(A);

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

julia> lu!(F, B);

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

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

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

Примеры

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

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

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

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Factorization

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

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

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

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

Примеры

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

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

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

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

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

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

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

CholeskyPivoted

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

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

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

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

Примеры

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

julia> A = X * X';

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> A = X * X';

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

julia> L = sparse(C.L);

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

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

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

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

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

julia> L = sparse(C.L);

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

julia> L * L' ≈ A
true

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

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

Примеры

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

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

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

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

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

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

См. также cholesky.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LDLt <: Factorization

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

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

Примеры

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

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

ldlt(S::SymTridiagonal) -> LDLt

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

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

Примеры

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

julia> ldltS = ldlt(S);

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

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

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

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

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

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

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

ldlt!(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

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

См. также ldlt.

QR <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

QRCompactWY <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

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

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

QRPivoted <: Factorization

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

\[A P = Q R\]

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

\[A = Q R\]

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

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

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

Примеры

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

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

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

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

LQ <: Factorization

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

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

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

Примеры

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

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

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

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

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

lq(A) -> S::LQ

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

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

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

Примеры

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

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

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

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

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

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

Eigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

Примеры

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B; sortby) -> GeneralizedEigen

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

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

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

Примеры

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

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

julia> F = eigen(A, B);

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

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

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

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

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

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

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

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

Диапазон UnitRange irange указывает индексы отсортированных собственных значений, которые нужно искать.

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

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

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

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

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

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

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

Hessenberg <: Factorization

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

hessenberg(A) -> Hessenberg

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

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

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

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

Примеры

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

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

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

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

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

hessenberg!(A) -> Hessenberg

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

Schur <: Factorization

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

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

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

Примеры

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

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

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

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

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

schur(A) -> F::Schur

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

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

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

Примеры

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

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

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

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

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

schur!(A) -> F::Schur

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

Примеры

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

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

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

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

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

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

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

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

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

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

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

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

SVD <: Factorization

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

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

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

Примеры

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

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
singular values:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # destructuring via iteration

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

Тип матричной факторизации обобщенного разложения по сингулярным значениям (SVD) двух матриц A и B, таких, что A = F.U*F.D1*F.R0*F.Q' и B = F.V*F.D2*F.R0*F.Q'. Это тип возвращаемого значения функции матричной факторизации svd(_, _).

Для M-на-N матрицы A и P-на-N матрицы B,

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

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

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

Элементы F.D1 и F.D2 связаны, как объяснено в документации LAPACK для обобщенного SVD и процедуры xGGSVD3, которая вызывается внутри (в LAPACK 3.6.0 и новее).

Примеры

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

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

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

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

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

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

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

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

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

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

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

Примеры

julia> A = rand(4,3);

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

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

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

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

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

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Вычислить обобщенное SVD A и B, возвращая объект факторизации GeneralizedSVD F, так что [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

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

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

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

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

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

Примеры

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

julia> F = svd(A, B);

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

julia> H = R*Q';

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

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

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

julia> U == Uonly
true

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

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

svd!(A, B) -> GeneralizedSVD

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

svdvals(A)

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

Примеры

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

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

svdvals(A, B)

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

Примеры

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

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

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

svdvals!(A)

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

svdvals!(A, B)

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

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

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

См. также givens.

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

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

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

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

y = G*x

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

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

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

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

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

B = G*A

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

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

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

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

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

B = G*x

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

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

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

triu(M)

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

Примеры

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

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

triu(M, k::Integer)

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

Примеры

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

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

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

triu!(M)

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

triu!(M, k::Integer)

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

Примеры

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

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

tril(M)

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

Примеры

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

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

tril(M, k::Integer)

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

Примеры

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

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

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

tril!(M)

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

tril!(M, k::Integer)

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

Примеры

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

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

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

AbstractRange, возвращающая индексы k-й диагонали матрицы M. Дополнительно может быть указан стиль индексов, который определяет тип возвращаемого диапазона. Если indstyle isa IndexLinear (по умолчанию), это возвращает AbstractRange{Integer}. С другой стороны, если indstyle isa IndexCartesian, это возвращает AbstractRange{CartesianIndex{2}}.

Если k не указано, предполагается, что это 0 (соответствующая главной диагонали).

См. также: 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

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

diag(M, k::Integer=0)

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

rank(::QRSparse{Tv,Ti}) -> Ti

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

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

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

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

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

Примеры

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

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

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

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

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

norm(A, p::Real=2)

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

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

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

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

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

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

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

Примеры

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

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

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

julia> norm(1:9)
16.881943016134134

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

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

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

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

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

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

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

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

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

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

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

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

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

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

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

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

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

normalize(a, p::Real=2)

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

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

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

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

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

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

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

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

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

tr(M)

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

Примеры

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

julia> tr(A)
5

det(M)

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

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

Примеры

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

julia> det(M)
2.0

logdet(M)

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

Примеры

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

julia> logdet(M)
0.6931471805599453

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

logabsdet(M)

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

Примеры

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

julia> det(A)
-1.0

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

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

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

Примеры

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

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

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

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

Вычисляет псевдообратную матрицу по Мур-Пенрозу.

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

kron(A, B)

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

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

Примеры

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

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

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

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

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

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

kron!(C, A, B)

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

exp(A::AbstractMatrix)

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

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

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

Примеры

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

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

cis(A::AbstractMatrix)

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

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

Примеры

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

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

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

Примеры

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

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

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

Примеры

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

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

log(A::AbstractMatrix)

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

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

Примеры

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

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

sqrt(x)

Возвращает $\sqrt{x}$.

Выбрасывает DomainError для отрицательных аргументов Real. Вместо этого используйте комплексные отрицательные аргументы. Обратите внимание, что sqrt имеет разрыв ветви вдоль отрицательной вещественной оси.

Префиксный оператор √ эквивалентен sqrt.

См. также: hypot.

Примеры

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im is below the branch cut
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

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

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

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

Примеры

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

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

cbrt(A::AbstractMatrix{<:Real})

Вычисляет вещественный кубический корень вещественной матрицы A. Если T = cbrt(A), то у нас есть T*T*T ≈ A, см. пример ниже.

Если A является симметричной, т. е. типа HermOrSym{<:Real}, для поиска кубического корня используется (eigen). В противном случае используется специализированная версия алгоритма p-ой степени ^[S03], которая использует вещественное разложение Шура (schur) для вычисления кубического корня.

Примеры

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

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

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

Примеры

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

sin(A::AbstractMatrix)

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

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

Примеры

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

sincos(A::AbstractMatrix)

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

Примеры

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

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

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

tan(A::AbstractMatrix)

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

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

Примеры

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

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

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

asin(A::AbstractMatrix)

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

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

Примеры

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

atan(A::AbstractMatrix)

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

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

Примеры

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

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

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

Примеры

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

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

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

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

sylvester(A, B, C)

Вычисляет решение X для уравнения Сильвестра AX + XB + C = 0, где A, B и C имеют совместимые размеры, и A и -B не имеют собственных значений с одинаковой действительной частью.

Примеры

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

Проверка успешности факторизации матрицы.

Примеры

julia> F = cholesky([1 0; 0 1]);

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

Проверка успешности LU-факторизации матрицы. По умолчанию, факторизация, которая приводит к U-фактору с нулевым рангом, считается неудачной. Это можно изменить, передав allowsingular = true.

Примеры

julia> F = lu([1 2; 1 2], check = false);

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

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> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true

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> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

Проверка, является ли матрица диагональной в том смысле, что iszero(A[i,j]) истинно, за исключением случая i == j. Обратите внимание, что A не обязательно должна быть квадратной; если вам также нужно проверить, что это так, то необходимо проверить, что size(A, 1) == size(A, 2).

Примеры

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> isdiag(a)
false

julia> b = [im 0; 0 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  0+0im
 0+0im  0-1im

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false

ishermitian(A) -> Bool

Проверка, является ли матрица эрмитовой.

Примеры

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> ishermitian(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> ishermitian(b)
true

transpose(A)

Ленивая транспонирование. Изменение возвращаемого объекта должно надлежащим образом изменять A. Часто, но не всегда, возвращает Transpose(A), где Transpose — это оболочка ленивой транспонирования. Обратите внимание, что эта операция рекурсивна.

Эта операция предназначена для использования в линейной алгебре — для общих операций с данными см. permutedims, которая не является рекурсивной.

Примеры

julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # the transpose of a transpose unwraps the parent
true

julia> Transpose(B) # however, the constructor always wraps its argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # modifying B will modify A automatically

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

Для комплексных матриц операция adjoint эквивалентна сопряжённо-транспонированию.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

transpose AbstractVector — это строка-вектор:

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # compute the dot product
14

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

Ленивая транспозиция факторизации F. По умолчанию возвращает TransposeFactorization, за исключением случаев Factorization с вещественными eltype, в которых случае возвращается AdjointFactorization.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет её в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память не выделяется, кроме изменения размеров rowval и nzval у X, если необходимо.

См. halfperm!

transpose!(dest,src)

Транспонирует массив src и сохраняет результат в предварительно выделенном массиве dest, размер которого должен соответствовать (size(src,2),size(src,1)). Поддержка транспонирования на месте не реализована, и могут возникнуть неожиданные результаты, если src и dest имеют перекрывающиеся области памяти.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Transpose

Ленивая оболочка для представления транспонированной подлежащей линейной алгебраической структуры, обычно AbstractVector/AbstractMatrix. Обычно конструктор Transpose не следует вызывать напрямую, используйте transpose вместо этого. Для материализации представления используйте copy.

Этот тип предназначен для использования в линейной алгебре — для общих операций с данными см. permutedims.

Примеры

julia> A = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

Ленивая оболочка для транспонирования подлежащего объекта Factorization. Обычно конструктор TransposeFactorization не следует вызывать напрямую, используйте transpose(:: Factorization) вместо этого.

A'
adjoint(A)

Ленивый сопряжённый транспонирование. Обратите внимание, что adjoint применяется рекурсивно к элементам.

Для числовых типов adjoint возвращает комплексно сопряжённое значение, поэтому для вещественных чисел оно эквивалентно тождественной функции.

Эта операция предназначена для использования в линейной алгебре — для общих операций с данными см. permutedims.

Примеры

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # the adjoint of an adjoint unwraps the parent
true

julia> Adjoint(B) # however, the constructor always wraps its argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # modifying B will modify A automatically

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Для вещественных матриц операция adjoint эквивалентна transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

Сопряжённое транспонирование AbstractVector — это строка-вектор:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # compute the dot product, equivalently x' * x
25 + 0im

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint(F::Factorization)

Ленивое сопряжённое транспонирование факторизации F. По умолчанию возвращает оболочку AdjointFactorization.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет сопряжённые транспонированные элементы в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память не выделяется, кроме изменения размеров rowval и nzval у X, если необходимо.

См. halfperm!

adjoint!(dest,src)

Сопряжённо транспонирует массив src и сохраняет результат в предварительно выделенном массиве dest, размер которого должен соответствовать (size(src,2),size(src,1)). Поддержка транспонирования на месте не реализована, и могут возникнуть неожиданные результаты, если src и dest имеют перекрывающиеся области памяти.

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Adjoint

Ленивая оболочка для представления сопряжённого транспонирования подлежащего объекта линейной алгебры, обычно AbstractVector/AbstractMatrix. Обычно конструктор Adjoint не следует вызывать напрямую, используйте adjoint вместо этого. Для материализации представления используйте copy.

Этот тип предназначен для использования в линейной алгебре — для общих операций с данными см. permutedims.

Примеры

julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

Ленивая оболочка для сопряжённого транспонирования подлежащего объекта Factorization. Обычно конструктор AdjointFactorization не следует вызывать напрямую, используйте adjoint(:: Factorization) вместо этого.

copy(A::Transpose)
copy(A::Adjoint)

Вычисляет транспонирование/сопряжённое транспонирование матрицы. Обратите внимание, что транспонирование применяется рекурсивно к элементам.

Эта операция предназначена для использования в линейной алгебре — для общих операций с данными см. permutedims, которая не является рекурсивной.

Примеры

julia> A = [1 2im; -3im 4]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+2im
 0-3im  4+0im

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

Возвращает расстояние между последовательными элементами массива в первом измерении в единицах размера элемента.

Примеры

julia> A = [1,2,3,4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

Проверяет, является ли матрица квадратной, и возвращает размер. Для нескольких аргументов возвращает вектор.

Примеры

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops вычисляет пиковую скорость FLOPS компьютера, используя двойную точность gemm!. По умолчанию, если не указаны аргументы, она перемножает две Float64 матрицы размера n x n, где n = 4096. Если используемый BLAS использует несколько потоков, достигается более высокая скорость FLOPS. Количество потоков BLAS можно настроить с помощью BLAS.set_num_threads(n).

Если предоставлен ключевой аргумент eltype, peakflops создаст матрицы с элементами типа eltype для вычисления пиковой скорости FLOPS.

По умолчанию peakflops использует лучшее время из 3 попыток. Если указан ключевой аргумент ntrials, peakflops будет использовать указанное количество попыток для выбора лучшего времени.

Если ключевой аргумент parallel установлен в true, peakflops выполняется параллельно на всех процессорах. Возвращается скорость FLOPS всего параллельного компьютера. При параллельном выполнении используется только 1 поток BLAS. Аргумент n по-прежнему относится к размеру задачи, решаемой на каждом процессоре.

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Возвращает эрмитову часть квадратной матрицы A, определённую как (A + A') / 2, как матрицу Hermitian. Для вещественных матриц A это также известно как симметричная часть A; иногда это также называют «вещественной частью оператора». Необязательный аргумент uplo управляет соответствующим аргументом представления Hermitian. Для вещественных матриц последнее эквивалентно представлению Symmetric.

См. также hermitianpart! для соответствующей операции на месте.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Заменяет квадратную матрицу A на месте её эрмитовой частью (A + A') / 2 и возвращает Hermitian(A, uplo). Для вещественных матриц A это также известно как симметричная часть A.

См. также hermitianpart для соответствующей операции вне места.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с присоединённым значением следующим образом:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с транспонированием, как показано ниже:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Эффективно копирует элементы матрицы M в B с учетом параметра символа tM следующим образом:

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

См. также copyto! и copy_adjoint!.

mul!(Y, A, B) -> Y

Вычисляет произведение матрицы-матрицы или матрицы-вектора $A B$ и сохраняет результат в 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);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

Реализация

Для пользовательских типов матриц и векторов рекомендуется реализовывать 5-аргументную функцию mul! вместо прямой реализации 3-аргументной функции mul!, если это возможно.

mul!(C, A, B, α, β) -> C

Объединенное на месте умножение матриц-матриц или матриц-векторов $A B α + C β$. Результат сохраняется в C, перезаписывая его. Обратите внимание, что C не должно быть алиасом ни для A, ни для B.

Примеры

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

julia> C_original = [1.0 2.0; 3.0 4.0]; # A copy of the original value of C

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

Масштабирует массив B на скаляр a, перезаписывая B на месте. Используйте rmul! для умножения скаляра справа. Операция масштабирования соответствует семантике умножения * между a и элементом B. В частности, это также относится к умножению, включающему бесконечные числа, такие как NaN и ±Inf.

Примеры

julia> B = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывая B и возвращая результат. Здесь A должен быть специального типа матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторого ортогонального типа, см. QR.

Примеры

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

Масштабирует массив A на скаляр b, перезаписывая A на месте. Используйте lmul! для умножения скаляра слева. Операция масштабирования соответствует семантике умножения * между элементом A и b. В частности, это также относится к умножению, включающему бесконечные числа, такие как NaN и ±Inf.

Примеры

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывая A и возвращая результат. Здесь B должен быть специального типа матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторого ортогонального типа, см. QR.

Примеры

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

Вычисляет A \ B на месте и сохраняет результат в Y, возвращая результат.

Аргумент A не должен быть матрицей. Вместо матриц должен быть объект факторизации (например, созданный функциями factorize или cholesky). Причина в том, что сама факторизация является дорогостоящей и обычно выделяет память (хотя это также можно сделать на месте, например, с помощью lu!), а в критически важных для производительности ситуациях, требующих ldiv!, обычно также требуется тонкий контроль факторизации A.

Примеры

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y ≈ A\X
true

ldiv!(A, B)

Вычисляет A \ B на месте, перезаписывая B для хранения результата.

Аргумент A не должен быть матрицей. Вместо матриц должен быть объект факторизации (например, созданный функциями factorize или cholesky). Причина в том, что сама факторизация является дорогостоящей и обычно выделяет память (хотя это также можно сделать на месте, например, с помощью lu!), а в критически важных для производительности ситуациях, требующих ldiv!, обычно также требуется тонкий контроль факторизации A.

Примеры

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X ≈ A\Y
true

ldiv!(a::Number, B::AbstractArray)

Делит каждый элемент массива B на скаляр a, перезаписывая B на месте. Используйте rdiv! для деления скаляра справа.

Примеры

julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

Вычисляет A \ B на месте методом Гаусса с частичным выбором главного элемента и сохраняет результат в B, возвращая результат. При этом также перезаписываются диагональные элементы A.

rdiv!(A, B)

Вычисляет A / B на месте, перезаписывая A для хранения результата.

Аргумент B не должен быть матрицей. Вместо матриц должен быть объект факторизации (например, созданный функциями factorize или cholesky). Причина в том, что сама факторизация является дорогостоящей и обычно выделяет память (хотя это также можно сделать на месте, например, с помощью lu!), а в критически важных для производительности ситуациях, требующих rdiv!, обычно также требуется тонкий контроль факторизации B.

rdiv!(A::AbstractArray, b::Number)

Разделите каждое значение в массиве A на скаляр b, перезаписывая A значения на месте. Используйте ldiv! для деления скаляра слева.

Примеры

julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

Интерфейс к подпрограммам BLAS.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Установить количество потоков, которое должна использовать библиотека BLAS, равное n::Integer.

Также принимает nothing, в этом случае Julia пытается угадать значение по умолчанию. Передача nothing не рекомендуется и в основном существует по историческим причинам.

get_num_threads()

Получить количество потоков, используемых библиотекой BLAS.

rot!(n, X, incx, Y, incy, c, s)

Перезаписать X с c*X + s*Y и Y с -conj(s)*X + c*Y для первых n элементов массива X с шагом incx и первых n элементов массива Y с шагом incy. Возвращает X и Y.

scal!(n, a, X, incx)
scal!(a, X)

Перезаписать X с a*X для первых n элементов массива X с шагом incx. Возвращает X.

Если n и incx не предоставлены, используются length(X) и stride(X,1).

scal(n, a, X, incx)
scal(a, X)

Возвращает X, умноженное на a, для первых n элементов массива X с шагом incx.

Если n и incx не предоставлены, используются length(X) и stride(X,1).

blascopy!(n, X, incx, Y, incy)

Скопировать n элементов массива X с шагом incx в массив Y с шагом incy. Возвращает Y.

dot(n, X, incx, Y, incy)

Скалярное произведение двух векторов, состоящих из n элементов массива X с шагом incx и n элементов массива Y с шагом incy.

Примеры

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

Функция скалярного произведения для двух комплексных векторов, состоящих из n элементов массива X с шагом incx и n элементов массива Y с шагом incy.

Примеры

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

Функция скалярного произведения для двух комплексных векторов, состоящих из n элементов массива X с шагом incx и n элементов массива U с шагом incy, сопрягая первый вектор.

Примеры

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

2-норма вектора, состоящего из n элементов массива X с шагом incx.

Примеры

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

Сумма модулей первых n элементов массива X с шагом incx.

Для вещественного массива модуль — это абсолютное значение. Для комплексного массива модуль — это сумма абсолютных значений действительной и мнимой частей.

Примеры

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

Найти индекс элемента dx с максимальным абсолютным значением. n — длина dx, а incx — шаг. Если n и incx не указаны, они принимают значения по умолчанию n=length(dx) и incx=stride1(dx).

gemv!(tA, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y или alpha*A'x + beta*y в соответствии с tA. alpha и beta являются скалярами. Вернуть обновлённый y.

gemv(tA, alpha, A, x)

Вернуть alpha*A*x или alpha*A'x в соответствии с tA. alpha является скаляром.

gemv(tA, A, x)

Вернуть A*x или A'x в соответствии с tA.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y или alpha*A'*x + beta*y в соответствии с trans. Матрица A является общей полосовой матрицей размерности m на size(A,2) с kl поддиагоналями и ku наддиагоналями. alpha и beta являются скалярами. Вернуть обновлённый y.

gbmv(trans, m, kl, ku, alpha, A, x)

Вернуть alpha*A*x или alpha*A'*x в соответствии с trans. Матрица A является общей полосовой матрицей размерности m на size(A,2) с kl поддиагоналями и ku наддиагоналями, а alpha является скаляром.

hemv!(ul, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y. A предполагается эрмитовой. Используется только ul треугольник A. alpha и beta являются скалярами. Вернуть обновлённый y.

hemv(ul, alpha, A, x)

Вернуть alpha*A*x. A предполагается эрмитовой. Используется только ul треугольник A. alpha является скаляром.

hemv(ul, A, x)

Вернуть A*x. A предполагается эрмитовой. Используется только ul треугольник A.

hpmv!(uplo, α, AP, x, β, y)

Обновить вектор y как α*A*x + β*y, где A — эрмитова матрица, представленная в упакованном формате AP.

С uplo = 'U', массив AP должен содержать верхнюю треугольную часть эрмитовой матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

С uplo = 'L', массив AP должен содержать нижнюю треугольную часть эрмитовой матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярные входные данные α и β должны быть комплексными или вещественными числами.

Массивные входные данные x, y и AP должны быть всех типов ComplexF32 или ComplexF64.

Вернуть обновлённый y.

symv!(ul, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y. A предполагается симметричной. Используется только ul треугольник A. alpha и beta являются скалярами. Вернуть обновлённый y.

symv(ul, alpha, A, x)

Вернуть alpha*A*x. A предполагается симметричной. Используется только ul треугольник A. alpha является скаляром.

symv(ul, A, x)

Вернуть A*x. A предполагается симметричной. Используется только ul треугольник A.

sbmv!(uplo, k, alpha, A, x, beta, y)

Обновить вектор y как alpha*A*x + beta*y, где A — симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Схема хранения для A описана в справочном модуле BLAS, уровень-2 BLAS по адресу https://www.netlib.org/lapack/explore-html/. Используется только uplo треугольник A.

Вернуть обновлённый y.

sbmv(uplo, k, alpha, A, x)

Вернуть alpha*A*x, где A — симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Используется только uplo треугольник A.

sbmv(uplo, k, A, x)

Вернуть A*x, где A — симметричная полосовая матрица порядка size(A,2) с k наддиагоналями, хранящимися в аргументе A. Используется только uplo треугольник A.

spmv!(uplo, α, AP, x, β, y)

Обновить вектор y как α*A*x + β*y, где A — симметричная матрица, представленная в упакованном формате AP.

С uplo = 'U', массив AP должен содержать верхнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

С uplo = 'L', массив AP должен содержать нижнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярные входные данные α и β должны быть вещественными.

Массивные входные данные x, y и AP должны быть всех типов Float32 или Float64.

Вернуть обновлённый y.

trmv!(ul, tA, dA, A, b)

Вернуть op(A)*b, где op определяется tA. Используется только ul треугольник A. dA определяет, считываются ли значения диагоналей или предполагаются равными единице. Умножение происходит на месте в b.

trmv(ul, tA, dA, A, b)

Вернуть op(A)*b, где op определяется tA. Используется только ul треугольник A. dA определяет, считываются ли значения диагоналей или предполагаются равными единице.

trsv!(ul, tA, dA, A, b)

Перезапишите b решением для A*x = b или одним из двух других вариантов, определяемых tA и ul. dA определяет, читаются ли диагональные значения или предполагается, что они все равны единице. Верните обновлённую b.

trsv(ul, tA, dA, A, b)

Вернуть решение для A*x = b или один из двух других вариантов, определяемых tA и ul. dA определяет, читаются ли диагональные значения или предполагается, что они все равны единице.

ger!(alpha, x, y, A)

Обновление матрицы A ранга 1 векторами x и y как alpha*x*y' + A.

her!(uplo, alpha, x, A)

Методы только для комплексных массивов. Обновление эрмитовой матрицы A ранга 1 вектором x как alpha*x*x' + A. uplo управляет тем, какой треугольник A обновляется. Возвращает A.

syr!(uplo, alpha, x, A)

Обновление симметричной матрицы A ранга 1 вектором x как alpha*x*transpose(x) + A. uplo управляет тем, какой треугольник A обновляется. Возвращает A.

spr!(uplo, α, x, AP)

Обновление матрицы A как A+α*x*x', где A - симметричная матрица, представленная в упакованном формате AP, а x - вектор.

При использовании uplo = 'U' массив AP должен содержать верхнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

При использовании uplo = 'L' массив AP должен содержать нижнюю треугольную часть симметричной матрицы, упакованной последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

Скалярный ввод α должен быть вещественным.

Массивы ввода x и AP должны быть типа Float32 или Float64. Возвращает обновлённую AP.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

Обновление нижней или верхней треугольной части, указанной uplo матрицы C как alpha*A*B + beta*C или других вариантов в соответствии с tA и tB. Возвращает обновлённую C.

gemmt(uplo, tA, tB, alpha, A, B)

Возвращает нижнюю или верхнюю треугольную часть, указанную uplo матрицы A*B или другие три варианта в соответствии с tA и tB.

gemmt(uplo, tA, tB, A, B)

Возвращает нижнюю или верхнюю треугольную часть, указанную uplo матрицы A*B или другие три варианта в соответствии с tA и tB.

gemm!(tA, tB, alpha, A, B, beta, C)

Обновляет C как alpha*A*B + beta*C или другие три варианта в соответствии с tA и tB. Возвращает обновлённую C.

gemm(tA, tB, alpha, A, B)

Возвращает alpha*A*B или другие три варианта в соответствии с tA и tB.

gemm(tA, tB, A, B)

Возвращает A*B или другие три варианта в соответствии с tA и tB.

symm!(side, ul, alpha, A, B, beta, C)

Обновляет C как alpha*A*B + beta*C или alpha*B*A + beta*C в соответствии с side. A предполагается симметричным. Используется только треугольник ul A. Возвращает обновлённую C.

symm(side, ul, alpha, A, B)

Возвращает alpha*A*B или alpha*B*A в соответствии с side. A предполагается симметричным. Используется только треугольник ul A.

symm(side, ul, A, B)

Возвращает A*B или B*A в соответствии с side. A предполагается симметричным. Используется только треугольник ul A.

hemm!(side, ul, alpha, A, B, beta, C)

Обновляет C как alpha*A*B + beta*C или alpha*B*A + beta*C в соответствии с side. A предполагается эрмитовым. Используется только треугольник ul A. Возвращает обновлённую C.

hemm(side, ul, alpha, A, B)

Возвращает alpha*A*B или alpha*B*A в соответствии с side. A предполагается эрмитовым. Используется только треугольник ul A.

hemm(side, ul, A, B)

Возвращает A*B или B*A в соответствии с side. A предполагается эрмитовым. Используется только треугольник ul A.

syrk!(uplo, trans, alpha, A, beta, C)

Обновление симметричной матрицы C как alpha*A*transpose(A) + beta*C или alpha*transpose(A)*A + beta*C в соответствии с trans. Используется только треугольник uplo C. Возвращает C.

syrk(uplo, trans, alpha, A)

Возвращает либо верхнюю, либо нижнюю треугольную часть A в соответствии с uplo для alpha*A*transpose(A) или alpha*transpose(A)*A в соответствии с trans.

herk!(uplo, trans, alpha, A, beta, C)

Только для комплексных массивов. Обновление эрмитовой матрицы C как alpha*A*A' + beta*C или alpha*A'*A + beta*C в соответствии с trans. Обновляется только треугольник uplo C. Возвращает C.

herk(uplo, trans, alpha, A)

Методы только для комплексных массивов. Возвращает uplo треугольник alpha*A*A' или alpha*A'*A, в соответствии с trans.

syr2k!(uplo, trans, alpha, A, B, beta, C)

Обновление ранга-2k симметричной матрицы C как alpha*A*transpose(B) + alpha*B*transpose(A) + beta*C или alpha*transpose(A)*B + alpha*transpose(B)*A + beta*C в соответствии с trans. Используется только uplo треугольник C. Возвращает C.

syr2k(uplo, trans, alpha, A, B)

Возвращает uplo треугольник alpha*A*transpose(B) + alpha*B*transpose(A) или alpha*transpose(A)*B + alpha*transpose(B)*A, в соответствии с trans.

syr2k(uplo, trans, A, B)

Возвращает uplo треугольник A*transpose(B) + B*transpose(A) или transpose(A)*B + transpose(B)*A, в соответствии с trans.

her2k!(uplo, trans, alpha, A, B, beta, C)

Обновление ранга-2k эрмитовой матрицы C как alpha*A*B' + alpha*B*A' + beta*C или alpha*A'*B + alpha*B'*A + beta*C в соответствии с trans. Скаляр beta должен быть вещественным. Используется только uplo треугольник C. Возвращает C.

her2k(uplo, trans, alpha, A, B)

Возвращает uplo треугольник alpha*A*B' + alpha*B*A' или alpha*A'*B + alpha*B'*A, в соответствии с trans.

her2k(uplo, trans, A, B)

Возвращает uplo треугольник A*B' + B*A' или A'*B + B'*A, в соответствии с trans.

trmm!(side, ul, tA, dA, alpha, A, B)

Обновляет B как alpha*A*B или один из других трех вариантов, определяемых side и tA. Используется только ul треугольник A. dA определяет, считываются ли диагональные значения или предполагается, что они все равны единице. Возвращает обновлённую B.

trmm(side, ul, tA, dA, alpha, A, B)

Возвращает alpha*A*B или один из других трех вариантов, определяемых side и tA. Используется только ul треугольник A. dA определяет, считываются ли диагональные значения или предполагается, что они все равны единице.

trsm!(side, ul, tA, dA, alpha, A, B)

Перезаписывает B решением A*X = alpha*B или одним из трех других вариантов, определяемых side и tA. Используется только ul треугольник A. dA определяет, считываются ли диагональные значения или предполагается, что они все равны единице. Возвращает обновлённую B.

trsm(side, ul, tA, dA, alpha, A, B)

Возвращает решение A*X = alpha*B или один из трех других вариантов, определяемых side и tA. Используется только ul треугольник A. dA определяет, считываются ли диагональные значения или предполагается, что они все равны единице.

Интерфейсы к подпрограммам LAPACK.

gbtrf!(kl, ku, m, AB) -> (AB, ipiv)

Вычисление LU-разложения полосовой матрицы AB. kl — это первая поддиагональ, содержащая ненулевую полосу, ku — последняя наддиагональ, содержащая ненулевую полосу, а m — первая размерность матрицы AB. Возвращает LU-разложение на месте и ipiv, вектор используемых поворотов.

gbtrs!(trans, kl, ku, m, AB, ipiv, B)

Решение уравнения AB * X = B. trans определяет ориентацию AB. Это может быть N (без транспонирования), T (транспонирование) или C (сопряжённое транспонирование). kl — это первая поддиагональ, содержащая ненулевую полосу, ku — последняя наддиагональ, содержащая ненулевую полосу, а m — первая размерность матрицы AB. ipiv — вектор поворотов, возвращённый из gbtrf!. Возвращает вектор или матрицу X, перезаписывая B на месте.

gebal!(job, A) -> (ilo, ihi, scale)

Балансировка матрицы A перед вычислением её собственного системы или факторизации Шюра. job может быть одним из N (A не будет переставлена или масштабирована), P (A будет только переставлена), S (A будет только масштабирована) или B (A будет и переставлена, и масштабирована). Изменяет A на месте и возвращает ilo, ihi и scale. Если перестановка была включена, A[i,j] = 0, если j > i и 1 < j < ilo или j > ihi. scale содержит информацию о выполненных масштабированиях/перестановках.

gebak!(job, side, ilo, ihi, scale, V)

Преобразование собственных векторов V матрицы, сбалансированной с помощью gebal!, в несбалансированные/непереставленные собственные векторы исходной матрицы. Изменяет V на месте. side может быть L (преобразуются левые собственные векторы) или R (преобразуются правые собственные векторы).

gebrd!(A) -> (A, d, e, tauq, taup)

Приводит A на месте к бидиагональной форме A = QBP'. Возвращает A, содержащую бидиагональную матрицу B; d, содержащую диагональные элементы B; e, содержащую внедиагональные элементы B; tauq, содержащую элементарные отражения, представляющие Q; и taup, содержащую элементарные отражения, представляющие P.

gelqf!(A, tau)

Вычисление LQ факторизации A, A = LQ. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должна иметь длину, большую или равную наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

gelqf!(A) -> (A, tau)

Вычисление LQ факторизации A, A = LQ.

Возвращает A, изменённое на месте, и tau, содержащее скаляры, которые параметризуют элементарные отражения факторизации.

geqlf!(A, tau)

Вычислить QL факторизацию A, A = QL. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должен иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

geqlf!(A) -> (A, tau)

Вычислить QL факторизацию A, A = QL.

Возвращает A, изменённый на месте, и tau, который содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqrf!(A, tau)

Вычислить QR факторизацию A, A = QR. tau содержит скаляры, которые параметризуют элементарные отражения факторизации. tau должен иметь длину не меньше наименьшей размерности A.

Возвращает A и tau, изменённые на месте.

geqrf!(A) -> (A, tau)

Вычислить QR факторизацию A, A = QR.

Возвращает A, изменённый на месте, и tau, который содержит скаляры, которые параметризуют элементарные отражения факторизации.

geqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)

Вычислить факторизацию с выбором пивот-элементов QR A, AP = QR, используя BLAS уровня 3. P — матрица выбора пивот-элементов, представленная как jpvt. tau хранит элементарные отражения. Аргументы jpvt и tau являются необязательными и позволяют передавать предварительно выделенные массивы. При передаче, jpvt должен иметь длину не меньше n, если A — матрица (m x n), и tau должен иметь длину не меньше наименьшей размерности A. При входном значении, если jpvt[j] не равно нулю, то j-ый столбец A переставляется в начало AP.

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, ipiv) -> (A, ipiv, info)

Вычислить факторизацию с выбором пивот-элементов LU A, A = LU. ipiv содержит информацию о выборе пивот-элементов, а info — код, указывающий на успех (info = 0), сингулярное значение в U (info = i, в этом случае U[i,i] сингулярна), или код ошибки (info < 0).

getrf!(A) -> (A, ipiv, info)

Вычислить факторизацию с выбором пивот-элементов LU A, A = LU.

Возвращает A, изменённый на месте, ipiv, информацию о выборе пивот-элементов, и info код, указывающий на успех (info = 0), сингулярное значение в U (info = i, в этом случае U[i,i] сингулярна), или код ошибки (info < 0).

tzrzf!(A) -> (A, tau)

Преобразует верхнетреугольную матрицу A в верхнетреугольную форму на месте. Возвращает A и tau, скалярные параметры элементарных отражений преобразования.

ormrz!(side, trans, A, tau, C)

Умножает матрицу C на Q слева (side = L, Q*C) или справа (side = R, C*Q) с использованием преобразования, заданного tzrzf!. C может быть не модифицирована (trans = N), транспонирована (trans = T) или сопряжённо транспонирована (trans = C). Возвращает матрицу C, которая изменяется на месте с результатом умножения.

gels!(trans, A, B) -> (F, B, ssr)

Решает линейное уравнение A * X = B, transpose(A) * X = B или adjoint(A) * X = B с использованием QR или LQ факторизации. Модифицирует матрицу/вектор B на месте с решением. A перезаписывается с её QR или LQ факторизацией. trans может быть: N (без модификации), T (транспонирование) или C (сопряжённое транспонирование). gels! ищет решение с минимальной нормой/наименьшими квадратами. A может быть недоопределённой или переопределённой. Решение возвращается в B.

gesv!(A, B) -> (B, A, ipiv)

Решает линейное уравнение A * X = B, где A — квадратная матрица, используя LU факторизацию A. A перезаписывается с её LU факторизацией, а B перезаписывается с решением X. ipiv содержит информацию о выборе пивот-элементов для LU факторизации A.

getrs!(trans, A, ipiv, B)

Решает линейное уравнение A * X = B, transpose(A) * X = B или adjoint(A) * X = B для квадратной матрицы A. Модифицирует матрицу/вектор B на месте с решением. A — LU факторизация из getrf!, с ipiv информацией о выборе пивот-элементов. trans может быть: N (без модификации), T (транспонирование) или C (сопряжённое транспонирование).

getri!(A, ipiv)

Вычисляет обратную матрицу A, используя её LU факторизацию, полученную с помощью getrf!. ipiv — информация о выборе пивот-элементов, а A содержит LU факторизацию getrf!. A перезаписывается своей обратной матрицей.

gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)

Решает линейное уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) с помощью факторизации LU матрицы A. fact может быть E, в этом случае A будет выровнено и скопировано в AF; F, в этом случае AF и ipiv из предыдущей факторизации LU являются входными данными; или N, в этом случае A будет скопировано в AF и затем разложено. Если fact = F, то equed может быть N, что означает, что A не было выровнено; R, что означает, что A было умножено на Diagonal(R) слева; C, что означает, что A было умножено на Diagonal(C) справа; или B, что означает, что A было умножено на Diagonal(R) слева и Diagonal(C) справа. Если fact = F и equed = R или B, элементы матрицы R должны быть положительными. Если fact = F и equed = C или B, элементы матрицы C должны быть положительными.

Возвращает решение X; equed, которое является выводом, если fact не является N, и описывает выполненное выравнивание; R, диагональ выравнивания строк; C, диагональ выравнивания столбцов; B, которая может быть перезаписана своим выровненным аналогом Diagonal(R)*B (если trans = N и equed = R,B) или Diagonal(C)*B (если trans = T,C и equed = C,B); rcond, обратная условная величина A после выравнивания; ferr, граница погрешности вперёд для каждого вектора решения в X; berr, граница погрешности вперёд для каждого вектора решения в X; и work, обратный множитель роста опорного элемента.

gesvx!(A, B)

Упрощение gesvx! без выравнивания и транспонирования.

gelsd!(A, B, rcond) -> (B, rnk)

Вычисляет решение наименьшей нормы уравнения A * X = B, найдя факторизацию SVD матрицы A, а затем, используя метод «разделяй и властвуй». Матрица B перезаписывается решением X. Сингулярные значения меньше rcond будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gelsy!(A, B, rcond) -> (B, rnk)

Вычисляет решение наименьшей нормы уравнения A * X = B, найдя полную факторизацию QR матрицы A, а затем, используя метод «разделяй и властвуй». Матрица B перезаписывается решением X. Сингулярные значения меньше rcond будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gglse!(A, c, B, d) -> (X,res)

Решает уравнение A * x = c, где x подчиняется ограничению равенства B * x = d. Использует формулу ||c - A*x||^2 = 0 для решения. Возвращает X и остаточную сумму квадратов.

geev!(jobvl, jobvr, A) -> (W, VL, VR)

Находит собственную систему матрицы A. Если jobvl = N, собственные левые векторы матрицы A не вычисляются. Если jobvr = N, собственные правые векторы матрицы A не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются. Возвращает собственные значения в W, правые собственные векторы в VR и левые собственные векторы в VL.

gesdd!(job, A) -> (U, S, VT)

Находит сингулярное разложение матрицы A, A = U * S * V', используя подход «разделяй и властвуй». Если job = A, все столбцы матрицы U и строки матрицы V' вычисляются. Если job = N, ни столбцы U, ни строки V' не вычисляются. Если job = O, матрица A перезаписывается столбцами (узкой) матрицы U и строками (узкой) матрицы V'. Если job = S, столбцы (узкой) матрицы U и строки (узкой) матрицы V' вычисляются и возвращаются отдельно.

gesvd!(jobu, jobvt, A) -> (U, S, VT)

Находит сингулярное разложение матрицы A, A = U * S * V'. Если jobu = A, все столбцы матрицы U вычисляются. Если jobvt = A, все строки матрицы V' вычисляются. Если jobu = N, столбцы матрицы U не вычисляются. Если jobvt = N, строки матрицы V' не вычисляются. Если jobu = O, матрица A перезаписывается столбцами (узкой) матрицы U. Если jobvt = O, матрица A перезаписывается строками (узкой) матрицы V'. Если jobu = S, столбцы (узкой) матрицы U вычисляются и возвращаются отдельно. Если jobvt = S, строки (узкой) матрицы V' вычисляются и возвращаются отдельно. jobu и jobvt не могут быть одновременно O.

Возвращает U, S и Vt, где S — это сингулярные значения матрицы A.

ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

Находит обобщённое сингулярное разложение матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. Матрица D1 имеет alpha на диагонали, а матрица D2 имеет beta на диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq равны N, эта матрица не вычисляется. Данная функция доступна только в версиях LAPACK до 3.6.0.

ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

Находит обобщённое сингулярное разложение матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. Матрица D1 имеет alpha на диагонали, а матрица D2 имеет beta на диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq равны N, эта матрица не вычисляется. Данная функция требует LAPACK 3.6.0.

geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)

Находит собственную систему матрицы A с балансировкой матрицы. Если jobvl = N, собственные левые векторы матрицы A не вычисляются. Если jobvr = N, собственные правые векторы матрицы A не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются. Если balanc = N, балансировка не выполняется. Если balanc = P, A переставляется, но не масштабируется. Если balanc = S, A масштабируется, но не переставляется. Если balanc = B, A переставляется и масштабируется. Если sense = N, обратные условные числа не вычисляются. Если sense = E, обратные условные числа вычисляются только для собственных значений. Если sense = V, обратные условные числа вычисляются только для правых собственных векторов. Если sense = B, обратные условные числа вычисляются для правых и левых собственных векторов. Если sense = E,B, правые и левые собственные векторы должны быть вычислены.

ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)

Находит обобщённое разложение собственных векторов матриц A и B. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются.

ggev3!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)

Находит обобщенное собственное разложение A и B, используя блочный алгоритм. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются. Эта функция требует LAPACK 3.6.0.

gtsv!(dl, d, du, B)

Решает уравнение A * X = B, где A — треугольная матрица с dl на побочной диагонали, d на главной диагонали и du на наддиагонали.

Заменяет B решением X и возвращает его.

gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)

Находит факторизацию LU треугольной матрицы с dl на побочной диагонали, d на главной диагонали и du на наддиагонали.

Изменяет dl, d и du на месте и возвращает их, а также вторую наддиагональ du2 и вектор перестановки ipiv.

gttrs!(trans, dl, d, du, du2, ipiv, B)

Решает уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C), используя факторизацию LU, вычисленную функцией gttrf!. B перезаписывается решением X.

orglq!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации LQ после вызова gelqf! над A. Использует результат вызова gelqf!. A перезаписывается значением Q.

orgqr!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации QR после вызова geqrf! над A. Использует результат вызова geqrf!. A перезаписывается значением Q.

orgql!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации QL после вызова geqlf! над A. Использует результат вызова geqlf!. A перезаписывается значением Q.

orgrq!(A, tau, k = length(tau))

Явно находит матрицу Q факторизации RQ после вызова gerqf! над A. Использует результат вызова gerqf!. A перезаписывается значением Q.

ormlq!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации LQ матрицы A, вычисленной с помощью gelqf!. C перезаписывается.

ormqr!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации QR матрицы A, вычисленной с помощью geqrf!. C перезаписывается.

ormql!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации QL матрицы A, вычисленной с помощью geqlf!. C перезаписывается.

ormrq!(side, trans, A, tau, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации RQ матрицы A, вычисленной с помощью gerqf!. C перезаписывается.

gemqrt!(side, trans, V, T, C)

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентное правое умножение для side = R, используя Q из факторизации QR матрицы A, вычисленной с помощью geqrt!. C перезаписывается.

posv!(uplo, A, B) -> (A, B)

Находит решение уравнения A * X = B, где A — симметричная или эрмитова положительно определённая матрица. Если uplo = U, вычисляется верхняя факторизация Холецкого A. Если uplo = L, вычисляется нижняя факторизация Холецкого A. A перезаписывается своей факторизацией Холецкого. B перезаписывается решением X.

potrf!(uplo, A)

Вычисляет факторизацию Холецкого (верхнюю, если uplo = U, нижнюю, если uplo = L) положительно определённой матрицы A. A перезаписывается и возвращается с кодом информации.

potri!(uplo, A)

Вычисляет обратную матрицу A положительно определённой матрицы после вызова potrf! для нахождения её (верхней, если uplo = U, нижней, если uplo = L) факторизации Холецкого.

A перезаписывается своей обратной матрицей и возвращается.

potrs!(uplo, A, B)

Находит решение уравнения A * X = B, где A — симметричная или эрмитова положительно определённая матрица, чья факторизация Холецкого была вычислена функцией potrf!. Если uplo = U, то была вычислена верхняя факторизация Холецкого A. Если uplo = L, то была вычислена нижняя факторизация Холецкого A. B перезаписывается решением X.

pstrf!(uplo, A, tol) -> (A, piv, rank, info)

Вычисляет (верхнюю, если uplo = U, нижнюю, если uplo = L) факторизацию Холецкого с перестановкой положительно определённой матрицы A с заданной пользователем точностью tol. A перезаписывается своей факторизацией Холецкого.

Возвращает A, векторы перестановок piv, ранг A и код info. Если info = 0, факторизация выполнена успешно. Если info = i > 0, матрица A является неопределённой или имеет недостаточный ранг.

ptsv!(D, E, B)

Решает A * X = B для положительно определённой трёхдиагональной матрицы A. D — диагональ A, а E — внедиагональ. B перезаписывается решением X и возвращается.

pttrf!(D, E)

Вычисляет факторизацию LDLt положительно определённой трёхдиагональной матрицы с диагональю D и внедиагональю E. D и E перезаписываются и возвращаются.

pttrs!(D, E, B)

Решает A * X = B для положительно определённой трёхдиагональной матрицы A с диагональю D и внедиагональю E после вычисления факторизации LDLt A с помощью pttrf!. B перезаписывается решением X.

trtri!(uplo, diag, A)

Находит обратную матрицу (верхнетреугольную, если uplo = U, нижнетреугольную, если uplo = L) треугольной матрицы A. Если diag = N, то A имеет ненулевые диагональные элементы. Если diag = U, все диагональные элементы A равны единице. Матрица A перезаписывается своим обратным значением.

trtrs!(uplo, trans, diag, A, B)

Решает уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) для (верхнетреугольной, если uplo = U, нижнетреугольной, если uplo = L) треугольной матрицы A. Если diag = N, то A имеет ненулевые диагональные элементы. Если diag = U, все диагональные элементы A равны единице. B перезаписывается решением X.

trcon!(norm, uplo, diag, A)

Находит обратную условную величину (верхнетреугольной, если uplo = U, нижнетреугольной, если uplo = L) треугольной матрицы A. Если diag = N, A имеет ненулевые диагональные элементы. Если diag = U, все диагональные элементы A равны единице. Если norm = I, условная величина находится в бесконечной норме. Если norm = O или 1, условная величина находится в норме 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.

sytrf!(uplo, A, ipiv) -> (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.

hetrf!(uplo, A, ipiv) -> (A, ipiv, info)

Вычисляет факторизацию Банча-Кофмана эрмитовой матрицы A. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина.

Возвращает A, перезаписанную факторизацией, вектор поворота ipiv и код ошибки info, который является целым числом без знака. Если info положительно, матрица является вырожденной, и диагональная часть факторизации равна точно нулю в позиции info.

hetri!(uplo, A, ipiv)

Вычисляет обратную матрицу эрмитовой матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина. A перезаписывается своей обратной матрицей.

hetrs!(uplo, A, ipiv, B)

Решает уравнение A * X = B для эрмитовой матрицы A, используя результаты из sytrf!. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина. B перезаписывается решением X.

syev!(jobz, uplo, A)

Находит собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A. Если uplo = U, используется верхний треугольник A. Если uplo = L, используется нижний треугольник A.

syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)

Находит собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A. Если uplo = U, используется верхний треугольник A. Если uplo = L, используется нижний треугольник A. Если range = A, находятся все собственные значения. Если range = V, находятся собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, находятся собственные значения с индексами между il и iu. abstol может быть установлено как толерантность сходимости.

Собственные значения возвращаются в W, а собственные векторы — в Z.

syevd!(jobz, uplo, A)

Находит собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A. Если uplo = U, используется верхний треугольник A. Если uplo = L, используется нижний треугольник A.

Использует метод деления и объединения вместо итерации QR, используемой в syev!, или нескольких относительно устойчивых представлений, используемых в syevr!. См. James W. Demmel et al, SIAM J. Sci. Comput. 30, 3, 1508 (2008) для сравнения точности и производительности различных методов.

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

Находит обобщенные собственные значения (jobz = N) или обобщенные собственные значения и собственные векторы (jobz = V) симметричной матрицы A и симметричной положительно определенной матрицы B. Если uplo = U, используются верхние треугольники A и B. Если uplo = L, используются нижние треугольники A и B. Если itype = 1, решаемая задача — A * x = lambda * B * x. Если itype = 2, решаемая задача — A * B * x = lambda * x. Если itype = 3, решаемая задача — B * A * x = lambda * x.

bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на внедиагональных элементах. Если uplo = U, e_ является наддиагональю. Если uplo = L, e_ является поддиагональю. Также можно вычислить произведение Q' * C.

Возвращает сингулярные значения в d и матрицу C, перезаписанную Q' * C.

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

Вычисляет сингулярное разложение бидиагональной матрицы с d на диагонали и e_ на внедиагональных элементах, используя метод деления и объединения. Если uplo = U, e_ является наддиагональю. Если uplo = L, e_ является поддиагональю. Если compq = N, находятся только сингулярные значения. Если compq = I, находятся сингулярные значения и векторы. Если compq = P, сингулярные значения и векторы находятся в компактной форме. Работает только для вещественных типов.

Возвращает сингулярные значения в d, и если compq = P, компактные сингулярные векторы в iq.

gecon!(normtype, A, anorm)

Находит обратную величину числовой обусловленности матрицы A. Если normtype = I, числовая обусловленность находится в норме бесконечности. Если normtype = O или 1, числовая обусловленность находится в норме единицы. A должно быть результатом из getrf!, и anorm — нормой A в соответствующей норме.

gehrd!(ilo, ihi, A) -> (A, tau)

Преобразует матрицу A в форму Хессенберга. Если A сбалансирована с gebal!, то ilo и ihi — результаты из gebal!. В противном случае они должны быть ilo = 1 и ihi = size(A,2). tau содержит элементарные отражения факторизации.

orghr!(ilo, ihi, A, tau)

Явно находит Q, ортогональную/унитарную матрицу из gehrd!. ilo, ihi, A и tau должны соответствовать вводу/выводу к gehrd!.

gees!(jobvs, A) -> (A, vs, w)

Вычисляет собственные значения (jobvs = N) или собственные значения и векторы Шур (jobvs = V) матрицы A. A перезаписывается своей формой Шур.

Возвращает A, vs, содержащие векторы Шур, и w, содержащие собственные значения.

gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)

Вычисляет обобщенные собственные значения, обобщенную форму Шур, левые векторы Шур (jobsvl = V) или правые векторы Шур (jobvsr = V) из A и B.

Обобщенные собственные значения возвращаются в alpha и beta. Левые векторы Шур возвращаются в vsl, а правые — в vsr.

gges3!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)

Вычисляет обобщенные собственные значения, обобщенную форму Шур, левые векторы Шур (jobsvl = V) или правые векторы Шур (jobvsr = V) из A и B, используя блочный алгоритм. Эта функция требует LAPACK 3.6.0.

Обобщенные собственные значения возвращаются в alpha и beta. Левые векторы Шур возвращаются в vsl, а правые — в vsr.

trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)

Переупорядочивает факторизацию Шур T матрицы, так чтобы диагональный блок из T с индексом строки ifst был перемещен в строку с индексом ilst. Если compq = V, векторы Шур Q переупорядочиваются. Если compq = N, они не изменяются. 4-аргументный метод вызывает 5-аргументный метод с compq = V.

trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)

Переупорядочьте факторизацию Шура матрицы и, необязательно, найдите обратные числовые характеристики. Если job = N, числовые характеристики не находятся. Если job = E, находится только числовая характеристика для этого кластера собственных значений. Если job = V, находится только числовая характеристика для инвариантного подпространства. Если job = B, то находятся числовые характеристики для кластера и подпространства. Если compq = V, векторы Шура Q обновляются. Если compq = N, векторы Шура не изменяются. select определяет, какие собственные значения находятся в кластере. Метод с 3 аргументами вызывает метод с 5 аргументами с job = N и compq = V.

Возвращает T, Q, переупорядоченные собственные значения в w, числовую характеристику кластера собственных значений s и числовую характеристику инвариантного подпространства sep.

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщенного разложения Шура. select определяет собственные значения в каждом кластере.

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

Решает уравнение Сильвестра для матрицы A * X +/- X * B = scale*C, где A и B являются квазиверхнетреугольными. Если transa = N, A не изменяется. Если transa = T, A транспонируется. Если transa = C, A сопряжено транспонируется. Аналогично для transb и B. Если isgn = 1, решается уравнение A * X + X * B = scale * C. Если isgn = -1, решается уравнение A * X - X * B = scale * C.

Возвращает X (перезаписывая C) и scale.

hseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)

Вычисляет все собственные значения и (необязательно) факторизацию Шура матрицы, приведенной к форме Хессенберга. Если H сбалансировано с помощью gebal!, то ilo и ihi — это результаты gebal!. В противном случае они должны быть ilo = 1 и ihi = size(H,2). tau содержит элементарные отражатели факторизации.