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

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

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

Примеры

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

\(A, B)

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

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

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

Примеры

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

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

julia> A * X == B
true

SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

dot(x, y)
x ⋅ y

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

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

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

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

Примеры

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

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

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

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

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

julia> dot(x, y)
150.0

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

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

Примеры

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

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

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

factorize(A)

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

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

Примеры

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Array{Float64,2}:
 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,Array{Float64,1}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

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

Diagonal(A::AbstractMatrix)

Построение матрицы из диагонали A.

Примеры

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

julia> Diagonal(A)
3×3 Diagonal{Int64,Array{Int64,1}}:
 1  ⋅  ⋅
 ⋅  5  ⋅
 ⋅  ⋅  9

Diagonal(V::AbstractVector)

Построение матрицы с V в качестве диагонали.

Примеры

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

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

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

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

Примеры

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

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

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

julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
4×4 Bidiagonal{Int64,Array{Int64,1}}:
 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 Array{Int64,2}:
 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,Array{Int64,1}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

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

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

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

Примеры

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

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,Array{Int64,1}}:
 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 Array{Int64,2}:
 1  2  3  4
 1  2  3  4
 1  2  3  4
 1  2  3  4

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

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

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

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

LowerTriangular(A::AbstractMatrix)

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

Примеры

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Array{Float64,2}:
 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,Array{Float64,2}}:
 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 Array{Float64,2}:
 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,Array{Float64,2}}:
 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 Array{Float64,2}:
 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,Array{Float64,2}}:
 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 Array{Float64,2}:
 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,Array{Float64,2}}:
 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 Array{Int64,2}:
  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16

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

UniformScaling{T<:Number}

Масштабирование с одинаковым коэффициентом произвольного размера, определяемое как скаляр, умноженный на оператор тождества, λ*I. Также см. I.

Примеры

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

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

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

I

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

Примеры

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

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

LinearAlgebra.Factorization

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

LU <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

Cholesky <: Factorization

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

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

Примеры

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

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

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

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

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

CholeskyPivoted

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

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

Примеры

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

julia> C = cholesky(A, Val(true))
CholeskyPivoted{Float64,Array{Float64,2}}
U factor with rank 3:
3×3 UpperTriangular{Float64,Array{Float64,2}}:
 9.89949  -4.34366  -1.61624
  ⋅        4.25825   1.1694
  ⋅         ⋅        0.142334
permutation:
3-element Array{Int64,1}:
 3
 2
 1

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

LDLt <: Factorization

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

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

Примеры

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

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

ldlt(S::SymTridiagonal) -> LDLt

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

Примеры

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 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 Array{Float64,1}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Array{Float64,1}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

ldlt!(S::SymTridiagonal) -> LDLt

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

Примеры

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 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,Array{Float64,1}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

QR <: Factorization

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

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

Итерация разложения даёт компоненты 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 матрица, то

где $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$, удовлетворяет

таким образом, что $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 матрица, то

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
  5.0   7.0
 -2.0  -4.0

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

julia> S.L * S.Q
2×2 Array{Float64,2}:
  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).

Примеры

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

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

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

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

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

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64,Array{Float64,2}}
D factor:
2×2 Tridiagonal{Float64,Array{Float64,1}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64,Array{Float64,2}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Array{Int64,1}:
 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,Array{Float64,2}}
D factor:
2×2 Tridiagonal{Float64,Array{Float64,1}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64,Array{Float64,2}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Array{Int64,1}:
 2
 1

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

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

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

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64,Array{Float64,2}}
D factor:
2×2 Tridiagonal{Float64,Array{Float64,1}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64,Array{Float64,2}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Array{Int64,1}:
 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,Array{Float64,2}}
D factor:
2×2 Tridiagonal{Float64,Array{Float64,1}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64,Array{Float64,2}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Array{Int64,1}:
 2
 1

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

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

Eigen <: Factorization

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

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

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

Примеры

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

julia> F.values
3-element Array{Float64,1}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Array{Float64,2}:
 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 Array{Int64,2}:
 1   0
 0  -1

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

julia> F = eigen(A, B)
GeneralizedEigen{Complex{Float64},Complex{Float64},Array{Complex{Float64},2},Array{Complex{Float64},1}}
values:
2-element Array{Complex{Float64},1}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Array{Complex{Float64},2}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Array{Complex{Float64},1}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Array{Complex{Float64},2}:
  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 Array{Int64,2}:
 1  0
 0  4

julia> eigvals(diag_matrix)
2-element Array{Float64,1}:
 1.0
 4.0

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

julia> eigvals(A,B)
2-element Array{Complex{Float64},1}:
 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,Array{Float64,1}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -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,Array{Float64,1}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -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 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

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

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

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

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

Примеры

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

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

julia> eigvals!(A, B)
2-element Array{Complex{Float64},1}:
 0.0 - 1.0im
 0.0 + 1.0im

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

julia> B
2×2 Array{Float64,2}:
 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 Array{Complex{Int64},2}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmax(A)
1.0

julia> A = [0 im; -1 0]
2×2 Array{Complex{Int64},2}:
  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 Array{Complex{Int64},2}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Array{Complex{Int64},2}:
  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. (N-ый собственный вектор можно получить из среза M[:, k].)

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

Примеры

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

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

julia> eigvecs(A)
3×3 Array{Float64,2}:
  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 Array{Float64,2}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

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

Возвращает матрицу M, столбцы которой являются собственными векторами A. (N-ый собственный вектор можно получить из среза 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 Array{Float64,2}:
 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. (N-ый собственный вектор можно получить из среза M[:, k].)

Примеры

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

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

julia> eigvecs(A, B)
2×2 Array{Complex{Float64},2}:
  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, возвращая объект факторизации F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (N-ый собственный вектор можно получить из среза 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,Array{Float64,2},Array{Float64,1}}
values:
3-element Array{Float64,1}:
  1.0
  3.0
 18.0
vectors:
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Array{Float64,1}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

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

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

eigen(A, B) -> GeneralizedEigen

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

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

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

Примеры

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

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

julia> F = eigen(A, B);

julia> F.values
2-element Array{Complex{Float64},1}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Array{Complex{Float64},2}:
  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, возвращая объект факторизации F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (N-ый собственный вектор можно получить из среза 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, возвращая объект факторизации F, содержащий собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (N-ый собственный вектор можно получить из среза F.vectors[:, k].)

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

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

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

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

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

Hessenberg <: Factorization

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

hessenberg(A) -> Hessenberg

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

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

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

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

Примеры

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Array{Float64,2}:
 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,Array{Float64,2}},Array{Float64,2},Array{Float64,1},Bool}
Q factor:
3×3 LinearAlgebra.HessenbergQ{Float64,Array{Float64,2},Array{Float64,1},false}:
 1.0   0.0        0.0
 0.0  -0.707107  -0.707107
 0.0  -0.707107   0.707107
H factor:
3×3 UpperHessenberg{Float64,Array{Float64,2}}:
  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 Array{Float64,2}:
 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 Array{Float64,2}:
  5.0   7.0
 -2.0  -4.0

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

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

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

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

GeneralizedSchur <: Factorization

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

julia> A
2×2 Array{Float64,2}:
 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 Array{Float64,2}:
 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,Array{Float64,2}}
U factor:
4×4 Array{Float64,2}:
 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 Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Array{Float64,2}:
 -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 Array{Float64,2}:
 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 Array{Float64,2}:
 1.0   0.0
 0.0  -1.0

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

julia> F = svd(A, B)
GeneralizedSVD{Float64,Array{Float64,2}}
U factor:
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Array{Float64,2}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 SparseArrays.SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 1]  =  0.707107
  [2, 2]  =  0.707107
D2 factor:
2×2 SparseArrays.SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 1]  =  0.707107
  [2, 2]  =  0.707107
R0 factor:
2×2 Array{Float64,2}:
 1.41421   0.0
 0.0      -1.41421

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

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

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

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

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

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

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

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

Примеры

julia> A = rand(4,3);

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

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

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

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

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

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

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

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

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

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

Обобщённое SVD используется в приложениях, например, когда нужно сравнить, сколько принадлежит A по сравнению с B, как в случае генома человека и дрожжей или сигнала и шума, или между кластерами и внутри кластеров. (См. обсуждение в 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 Array{Float64,2}:
 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 Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

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

Примеры

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

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

julia> svdvals(A, B)
2-element Array{Float64,1}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Int64,2}:
 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 Array{Int64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Int64,2}:
 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 Array{Int64,2}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M, k::Integer=0)

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

Примеры

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

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

diag(M, k::Integer=0)

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

См. также: diagm

Примеры

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

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

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

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

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

Примеры

julia> diagm(1 => [1,2,3])
4×4 Array{Int64,2}:
 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 Array{Int64,2}:
 0  1  0  0
 4  0  2  0
 0  5  0  3
 0  0  0  0

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

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

Примеры

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

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

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

Примеры

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

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

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

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

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

norm(A, p::Real=2)

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

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

где $a_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 Array{Int64,1}:
  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_{ij}$ — элементы $A$, а $m$ и $n$ — его размеры.

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

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

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(v::AbstractVector, p::Real=2)

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

normalize(v::AbstractVector, p::Real=2)

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

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

cond(M, p::Real=2)

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

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

Число обусловленности 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 Array{Int64,2}:
 1  2
 3  4

julia> tr(A)
5

det(M)

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

Примеры

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

julia> det(M)
2.0

logdet(M)

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

Примеры

julia> M = [1 0; 2 2]
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
 -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 Array{Float64,2}:
 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 Array{Int64,2}:
 2  5
 1  3

julia> N = inv(M)
2×2 Array{Float64,2}:
  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(one(eltype(M)))))).

Подробнее см. ^[issue8859], ^[B96], ^[S84], ^[KY88].

Примеры

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

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

julia> M * N
2×2 Array{Float64,2}:
 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 Array{Int64,2}:
 1  0  0
 0  1  0
 0  0  0

julia> nullspace(M)
3×1 Array{Float64,2}:
 0.0
 0.0
 1.0

julia> nullspace(M, rtol=3)
3×3 Array{Float64,2}:
 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 Array{Float64,2}:
 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 отличается слева и справа в этих выражениях (из-за хранения в порядке следования столбцов).

Примеры

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

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

julia> kron(A, B)
4×4 Array{Complex{Int64},2}:
 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 Array{Int64,2}:
 3   6
 4   8
 5  10

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

exp(A::AbstractMatrix)

Вычислить матричную экспоненту A, заданную выражением

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

Примеры

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

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

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

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

Примеры

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

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

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

Примеры

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

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

log(A{T}::StridedMatrix{T})

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

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

Примеры

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

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

sqrt(A::AbstractMatrix)

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

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

Примеры

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

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

cos(A::AbstractMatrix)

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

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

Примеры

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

sin(A::AbstractMatrix)

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

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

Примеры

julia> sin(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
 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 Array{Float64,2}:
 0.454649  0.454649
 0.454649  0.454649

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

tan(A::AbstractMatrix)

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

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

Примеры

julia> tan(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
 -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 Array{Complex{Float64},2}:
  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 Array{Complex{Float64},2}:
  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 Array{Complex{Float64},2}:
  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 Array{Float64,2}:
 3.0  4.0
 5.0  6.0

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

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

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

sylvester(A, B, C)

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

Примеры

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

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

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

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

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

issuccess(F::Factorization)

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

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

julia> LinearAlgebra.issuccess(F)
true

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

julia> LinearAlgebra.issuccess(F)
false

issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

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

Примеры

julia> A = [1 2; 2 50]
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
 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 Array{Int64,2}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(b)
true

julia> istril(b, -1)
false

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

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

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(b)
true

julia> istriu(b, 1)
false

isdiag(A) -> Bool

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

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

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

Примеры

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

julia> transpose(A)
2×2 Transpose{Complex{Int64},Array{Complex{Int64},2}}:
 3+2im  8+7im
 9+2im  4+6im

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

Transpose

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

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

Примеры

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

julia> transpose(A)
2×2 Transpose{Complex{Int64},Array{Complex{Int64},2}}:
 3+2im  8+7im
 9+2im  4+6im

adjoint(A)

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

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

Примеры

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

julia> adjoint(A)
2×2 Adjoint{Complex{Int64},Array{Complex{Int64},2}}:
 3-2im  8-7im
 9-2im  4-6im

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 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im

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

julia> adjoint!(B, A);

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

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

Adjoint

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

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

Примеры

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

julia> adjoint(A)
2×2 Adjoint{Complex{Int64},Array{Complex{Int64},2}}:
 3-2im  8-7im
 9-2im  4-6im

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

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

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

Примеры

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

julia> T = transpose(A)
2×2 Transpose{Complex{Int64},Array{Complex{Int64},2}}:
 1+0im  0-3im
 0+2im  4+0im

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

stride1(A) -> Int

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

Примеры

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Array{Int64,1}, 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 Array{Int64,1}:
 4
 5

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

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

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

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

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

Примеры

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

julia> Y
2×2 Array{Float64,2}:
 3.0  3.0
 7.0  7.0

Реализация

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

lmul!(A, B)

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

Примеры

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

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

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

julia> B
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
 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 Array{Int64,2}:
 1  2
 3  4

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

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

rmul!(A, B)

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

Примеры

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

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

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

julia> A
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
 2.0  1.0
 4.0  3.0

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

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

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

Примеры

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

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

julia> Y = zero(X);

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

julia> Y
3-element Array{Float64,1}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\X
3-element Array{Float64,1}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(A, B)

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

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

Примеры

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

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

julia> Y = copy(X);

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

julia> X
3-element Array{Float64,1}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\Y
3-element Array{Float64,1}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

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

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

Примеры

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

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

rdiv!(A, B)

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

Примеры

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

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

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

Примеры

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

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

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

nrm2(n, X, incx)

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

Примеры

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

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

asum(n, X, incx)

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

Примеры

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

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

axpy!(a, X, Y)

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

Примеры

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

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

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

axpby!(a, X, b, Y)

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

Примеры

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

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

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

scal!(n, a, X, incx)

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

scal(n, a, X, incx)

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

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

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

ger!(alpha, x, y, A)

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

syr!(uplo, alpha, x, A)

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

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

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

syrk(uplo, trans, alpha, A)

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

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

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

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

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

syr2k(uplo, trans, A, B)

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

her!(uplo, alpha, x, A)

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

her2k(uplo, trans, A, B)

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

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

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

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

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

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

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

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

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

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

sbmv(uplo, k, A, x)

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

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

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

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

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

gemm(tA, tB, A, B)

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

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

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

gemv(tA, alpha, A, x)

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

gemv(tA, A, x)

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

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

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

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

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

symm(side, ul, A, B)

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

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

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

symv(ul, alpha, A, x)

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

symv(ul, A, x)

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

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

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

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

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

hemm(side, ul, A, B)

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

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

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

hemv(ul, alpha, A, x)

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

hemv(ul, A, x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_num_threads(n)

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

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

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

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

Вычисление факторизации QR с поворотом A, AP = QR, используя уровень 3 BLAS. P — матрица поворота, представленная jpvt. tau хранит элементарные отражатели. jpvt должна иметь длину, большую или равную n, если A — матрица (m x n). tau должна иметь длину, большую или равную наименьшей размерности A.

A, jpvt и tau изменяются на месте.

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

Вычисление факторизации QR с поворотом A, AP = QR, используя уровень 3 BLAS. P — матрица поворота, представленная jpvt. jpvt должна иметь длину, большую или равную n, если A — матрица (m x n).

Возвращает A и jpvt, изменённые на месте, и tau, который хранит элементарные отражатели.

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

Вычислить повернутую QR факторизацию A, AP = QR, используя уровень BLAS 3.

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

gerqf!(A, tau)

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

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

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

Вычислить RQ факторизацию A, A = RQ.

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

geqrt!(A, T)

Вычислить блочную QR факторизацию A, A = QR. T содержит верхнетреугольные блочные отражатели, которые параметризуют элементарные отражатели факторизации. Первое измерение T задаёт размер блока и должно быть между 1 и n. Второе измерение T должно быть равно наименьшему измерению A.

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

geqrt!(A, nb) -> (A, T)

Вычислить блочную QR факторизацию A, A = QR. nb задаёт размер блока и должно быть между 1 и n, вторым измерением A.

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

geqrt3!(A, T)

Рекурсивно вычисляет блочную QR факторизацию A, A = QR. T содержит верхнетреугольные блочные отражатели, которые параметризуют элементарные отражатели факторизации. Первое измерение T задаёт размер блока и должно быть между 1 и n. Второе измерение T должно быть равно наименьшему измерению A.

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

geqrt3!(A) -> (A, T)

Рекурсивно вычисляет блочную QR факторизацию A, A = QR.

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

getrf!(A) -> (A, ipiv, info)

Вычислить повернутую LU факторизацию A, A = LU.

Возвращает A, изменённый на месте, ipiv, информацию о повороте, и код info, который указывает на успех (info = 0), сингулярное значение в U (info = i, в этом случае U[i,i] является сингулярной) или код ошибки (info < 0).

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

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

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

Умножает матрицу C на Q слева или справа, используя преобразование, заданное tzrzf!. В зависимости от side или trans, умножение может быть слева (side = L, Q*C) или справа (side = R, C*Q), а Q может быть неизменённой (trans = N), транспонированной (trans = T) или эрмитово-транспонированной (trans = C). Возвращает матрицу C, которая изменяется на месте в результате умножения.

gels!(trans, A, B) -> (F, B, ssr)

Решает линейное уравнение A * X = B, transpose(A) * X = B или adjoint(A) * X = B, используя QR или LQ факторизацию. Изменяет матрицу/вектор B на месте с решением. A перезаписывается своей QR или LQ факторизацией. trans может быть одним из значений (без изменения), (транспонирование), или (эрмитово-транспонирование). 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 может быть одним из значений (без изменения), (транспонирование) или (эрмитово-транспонирование).

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 из предыдущей факторизации являются входными данными; или N, в этом случае A будет скопирована в AF и затем разложена. Если fact = F, то equed может быть N, что означает, что A не была выровнена; R, что означает, что A была умножена слева на Diagonal(R); C, что означает, что A была умножена справа на Diagonal(C); или B, что означает, что A была умножена слева на Diagonal(R) и справа на Diagonal(C). Если fact = F и equed = R или B, все элементы матрицы R должны быть положительными. Если fact = F и equed = C или B, все элементы матрицы C должны быть положительными.

Возвращает решение X; equed, которое является выходным значением, если fact не N и описывает произведенное выравнивание; R, диагональ для выравнивания строк; C, диагональ для выравнивания столбцов; B, которая может быть перезаписана своим выровненным значением Diagonal(R)*B (если trans = N и equed = R,B) или Diagonal(C)*B (если trans = T,C и equed = C,B); rcond, обратная условная числовая характеристика A после выравнивания; ferr, граница ошибки вперёд для каждого вектора решения в X; berr, граница ошибки вперёд для каждого вектора решения в X; и work, обратный коэффициент роста опор.

gesvx!(A, B)

Упрощенное представление gesvx! без выравнивания и транспонирования.

gelsd!(A, B, rcond) -> (B, rnk)

Вычисляет решение с наименьшей нормой уравнения A * X = B, найдя факторизацию SVD матрицы A, а затем разделив и объединив задачу. B перезаписывается решением X. Сингулярные значения меньше rcond будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gelsy!(A, B, rcond) -> (B, rnk)

Вычисляет решение с наименьшей нормой уравнения A * X = B, найдя полную факторизацию QR матрицы A, а затем разделив и объединив задачу. B перезаписывается решением X. Сингулярные значения меньше rcond будут считаться нулевыми. Возвращает решение в B и эффективный ранг матрицы A в rnk.

gglse!(A, c, B, d) -> (X,res)

Решает уравнение A * x = c, где x подчинено условию равенства B * x = d. Использует формулу ||c - A*x||^2 = 0 для решения. Возвращает X и остаточную сумму квадратов.

geev!(jobvl, jobvr, A) -> (W, VL, VR)

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

gesdd!(job, A) -> (U, S, VT)

Находит сингулярное разложение A, A = U * S * V', используя подход «разделяй и властвуй». Если job = A, все столбцы U и строки V' вычисляются. Если job = N, столбцы U и строки V' не вычисляются. Если job = O, A перезаписывается столбцами (тонкой) матрицы U и строками (тонкой) матрицы V'. Если job = S, столбцы (тонкой) матрицы U и строки (тонкой) матрицы V' вычисляются и возвращаются отдельно.

gesvd!(jobu, jobvt, A) -> (U, S, VT)

Находит сингулярное разложение A, A = U * S * V'. Если jobu = A, все столбцы матрицы U вычисляются. Если jobvt = A, все строки матрицы V' вычисляются. Если jobu = N, столбцы матрицы U не вычисляются. Если jobvt = N, строки матрицы V' не вычисляются. Если jobu = O, A перезаписывается столбцами (тонкой) матрицы U. Если jobvt = O, A перезаписывается строками (тонкой) матрицы V'. Если jobu = S, столбцы (тонкой) матрицы U вычисляются и возвращаются отдельно. Если jobvt = S, строки (тонкой) матрицы V' вычисляются и возвращаются отдельно. jobu и jobvt не могут быть оба O.

Возвращает U, S и Vt, где S являются сингулярными значениями матрицы A.

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

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

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

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

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

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

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

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

gtsv!(dl, d, du, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

potrf!(uplo, A)

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

potri!(uplo, A)

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

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

potrs!(uplo, A, B)

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

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

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

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

ptsv!(D, E, B)

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

pttrf!(D, E)

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

pttrs!(D, E, B)

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

trtri!(uplo, diag, A)

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sytri!(uplo, A, ipiv)

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

sytrs!(uplo, A, ipiv, B)

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

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

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

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

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

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

hetri!(uplo, A, ipiv)

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

hetrs!(uplo, A, ipiv, B)

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

syev!(jobz, uplo, A)

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

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

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

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

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

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

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

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

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

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

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

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

gecon!(normtype, A, anorm)

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

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

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

orghr!(ilo, ihi, A, tau)

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

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

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

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

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

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

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

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

Переупорядочивает факторизацию Шюра матрицы. Если compq = V, векторы Шюра Q переупорядочиваются. Если compq = N, они не изменяются. ifst и ilst задают переупорядочивание векторов.

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

Переупорядочивает факторизацию Шюра матрицы и необязательно находит обратные числа обусловленности. Если job = N, числа обусловленности не находятся. Если job = E, находится только число обусловленности для этого кластера собственных значений. Если job = V, находится только число обусловленности для инвариантного подпространства. Если job = B, находятся числа обусловленности для кластера и подпространства. Если compq = V, векторы Шюра Q обновляются. Если compq = N, векторы Шюра не изменяются. select определяет, какие собственные значения находятся в кластере.

Возвращает 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.