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

*(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 в \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(_) для краткости).

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64,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.

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

Если 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 определяет допуск для определения ранга. Для отрицательных значений допуск равен машинной точности.

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

Если 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) для объекта F типа QR.

  • Поддиагональная часть содержит отражения $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), и оно полезно для вычисления решения с минимальной нормой lq(A) \ b для недоопределенной системы уравнений (матрица 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. (k-й собственный вектор можно получить из среза 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. (k-й собственный вектор можно получить из среза M[:, k].) Ключевые слова permute, scale, и sortby такие же, как и для eigen.

Примеры

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 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. (k-й обобщенный собственный вектор можно получить из среза 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, возвращая объект факторизации Eigen F, который содержит собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

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

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

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

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

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64,Float64,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, возвращая объект факторизации GeneralizedEigen F, который содержит обобщенные собственные значения в F.values и обобщенные собственные векторы в столбцах матрицы F.vectors. (k-й обобщенный собственный вектор можно получить из среза 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, возвращая объект факторизации Eigen F, который содержит собственные значения в F.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

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

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

Диапазон UnitRange irange задаёт индексы отсортированных собственных значений для поиска.

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

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

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

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

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

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

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

Hessenberg <: Factorization

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

hessenberg(A) -> Hessenberg

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

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

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

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

Примеры

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 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, такой что [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

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

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

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

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

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

Примеры

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

julia> F = svd(A, B);

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

julia> H = R*Q';

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

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

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

julia> U == Uonly
true

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

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

svd!(A, B) -> GeneralizedSVD

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

svdvals(A)

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

Примеры

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 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)

Индексы AbstractRange 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}...)

Построение матрицы из Pair-х диагоналей и векторов. Вектор 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)

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

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

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

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

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

Примеры

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

julia> b = normalize(a)
3-element 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

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

julia> norm(a)
6.48074069840786

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

cond(M, p::Real=2)

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

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

Число обусловленности Скела $\kappa_S$ матрицы M, необязательно относительно вектора 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 в левой и правой частях этих выражений (из-за хранения в формате «столбец-главный»). Для комплексных векторов внешнее произведение w * v' также отличается сопряжением v.

Примеры

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

В противном случае квадратный корень определяется методом Бьёрка—Хаммарлинга ^[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

A'
adjoint(A)

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

Для числовых типов 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

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

julia> x'x
25 + 0im

adjoint!(dest,src)

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

Примеры

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 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

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

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

Примеры

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. Используется только треугольная часть C в соответствии с uplo. Возвращает C.

syrk(uplo, trans, alpha, A)

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

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

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

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

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

syr2k(uplo, trans, A, B)

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

her!(uplo, alpha, x, A)

Только для комплексных массивов. Обновление эрмитовой матрицы A с вектором 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. Используется только треугольная часть C в соответствии с uplo. Возвращает C.

herk(uplo, trans, alpha, A)

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

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

Обновление эрмитовой матрицы C в виде alpha*A*B' + alpha*B*A' + beta*C или alpha*A'*B + alpha*B'*A + beta*C в зависимости от trans. Скаляр beta должен быть вещественным. Используется только треугольная часть C в соответствии с uplo. Возвращает 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. kl — это первая поддиагональ, содержащая ненулевой элемент, ku — последняя наддиагональ, содержащая ненулевой элемент, а m — первая размерность матрицы AB. Возвращает LU-разложение на месте и ipiv, вектор используемых пивот-элементов.

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

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

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

gerqf!(A, tau)

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

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

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

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

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

geqrt!(A, T)

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

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

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

Вычислить блочное QR разложение A, A = QR. nb задаёт размер блока и должно быть в пределах от 1 до n, второго измерения A.

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

geqrt3!(A, T)

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

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

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

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

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

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

Вычислить разложение с выбором опорных элементов LU A, A = LU.

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

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

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

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

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

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

Решает линейное уравнение A * X = B, transpose(A) * X = B, или adjoint(A) * X = B с помощью QR или LQ факторизации. Изменяет матрицу/вектор B на месте, с решением. A перезаписывается своей QR или LQ факторизацией. trans может быть одним из значений: N (без изменений), T (транспонирование), или C (эрмитово сопряжение). gels! ищет решение с минимальной нормой/наименьших квадратов. A может быть недоопределённым или переопределённым. Решение возвращается в B.

gesv!(A, B) -> (B, A, ipiv)

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

getrs!(trans, A, ipiv, B)

Решает линейное уравнение A * X = B, transpose(A) * X = B, или adjoint(A) * X = B для квадратной матрицы A. Изменяет матрицу/вектор B на месте, с решением. A - LU факторизация из getrf!, с ipiv информацией о выборе опорных элементов. trans может быть одним из значений: N (без изменений), T (транспонирование), или C (эрмитово сопряжение).

getri!(A, ipiv)

Вычисляет обратную матрицу A, используя её LU факторизацию, найденную функцией getrf!. ipiv - информация о выборе опорных элементов, A содержит LU факторизацию getrf!. A перезаписывается своей обратной матрицей.

gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)

Решает линейное уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T), или adjoint(A) * X = B (trans = C) с помощью факторизации LU матрицы A. fact может быть E, в этом случае A будет сбалансирована и скопирована в AF; F, в этом случае AF и ipiv из предыдущей факторизации являются входными данными; или 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) факторизацию Холецкого с выбором опор с заданной точностью tol для положительно определённой матрицы A. A перезаписывается факторизацией Холецкого.

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

ptsv!(D, E, B)

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

pttrf!(D, E)

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

pttrs!(D, E, B)

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

trtri!(uplo, diag, A)

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sytri!(uplo, A, ipiv)

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

sytrs!(uplo, A, ipiv, B)

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

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

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

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

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

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

hetri!(uplo, A, ipiv)

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

hetrs!(uplo, A, ipiv, B)

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

syev!(jobz, uplo, A)

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

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

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

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

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

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

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

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

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

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

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

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

gecon!(normtype, A, anorm)

Находит обратную условную величину матрицы A. Если normtype = I, условная величина находится в норме бесконечности. Если normtype = O или 1, условная величина находится в норме единицы. 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.