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

В дополнение к (и как часть) поддержки многомерных массивов, Julia предоставляет собственные реализации многих общих и полезных операций линейной алгебры. Базовые операции, такие как tr, det и inv, поддерживаются:

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

julia> tr(A)
3

julia> det(A)
104.0

julia> inv(A)
3×3 Array{Float64,2}:
 -0.451923   0.211538    0.0865385
  0.365385  -0.192308    0.0576923
  0.240385   0.0576923  -0.0673077

А также другие полезные операции, такие как поиск собственных значений или собственных векторов:

julia> A = [-4. -17.; 2. 2.]
2×2 Array{Float64,2}:
 -4.0  -17.0
  2.0    2.0

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

julia> eigvecs(A)
2×2 Array{Complex{Float64},2}:
  0.945905+0.0im        0.945905-0.0im
 -0.166924-0.278207im  -0.166924+0.278207im

Кроме того, Julia предоставляет множество разложений, которые могут быть использованы для ускорения задач, таких как решение линейных уравнений или возведение матрицы в степень, предварительно разложив матрицу в форму, более удобную (по производительности или памяти) для задачи. Подробнее см. документацию по factorize. В качестве примера:

julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
3×3 Array{Float64,2}:
   1.5   2.0  -4.0
   3.0  -1.0  -6.0
 -10.0   2.3   4.0

julia> factorize(A)
LU{Float64,Array{Float64,2}}
L factor:
3×3 Array{Float64,2}:
  1.0    0.0       0.0
 -0.15   1.0       0.0
 -0.3   -0.132196  1.0
U factor:
3×3 Array{Float64,2}:
 -10.0  2.3     4.0
   0.0  2.345  -3.4
   0.0  0.0    -5.24947

Поскольку A не является эрмитовой, симметричной, треугольной, трехдиагональной или бидиагональной, LU-разложение может быть наилучшим из возможных. Сравните с:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> factorize(B)
BunchKaufman{Float64,Array{Float64,2}}
D factor:
3×3 Tridiagonal{Float64,Array{Float64,1}}:
 -1.64286   0.0   ⋅
  0.0      -2.8  0.0
   ⋅        0.0  5.0
U factor:
3×3 UnitUpperTriangular{Float64,Array{Float64,2}}:
 1.0  0.142857  -0.8
  ⋅   1.0       -0.6
  ⋅    ⋅         1.0
permutation:
3-element Array{Int64,1}:
 1
 2
 3

Здесь Julia смогла определить, что B фактически является симметричной, и использовала более подходящее разложение. Часто можно написать более эффективный код для матрицы, о которой известно, что она обладает определенными свойствами, например, является симметричной или трехдиагональной. Julia предоставляет некоторые специальные типы, чтобы вы могли «пометить» матрицы как имеющие эти свойства. Например:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64,Array{Float64,2}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

sB была помечена как матрица, которая является (вещественной) симметричной, поэтому для последующих операций, которые мы можем выполнить над ней, таких как собственное разложение или вычисление произведений матрица-вектор, можно добиться эффективности, обращаясь только к половине матрицы. Например:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64,Array{Float64,2}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

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

julia> sB\x
3-element Array{Float64,1}:
 -1.7391304347826084
 -1.1086956521739126
 -1.4565217391304346

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

Специальные матрицы

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

В следующих таблицах обобщены типы специальных матриц, реализованных в Julia, а также наличие подключений к различным оптимизированным методам для них в LAPACK.

Элементарные операции

Легенда:

Разложения матриц

Легенда:

Оператор равномерного масштабирования

Оператор UniformScaling представляет скалярное произведение на оператор единичной матрицы, λ*I. Оператор единичной матрицы I определяется как константа и является экземпляром UniformScaling. Размер этих операторов является обобщенным и соответствует другим матрицам в бинарных операциях +, -, * и \. Для A+I и A-I это означает, что A должна быть квадратной. Умножение на оператор единичной матрицы I является бесполезной операцией (кроме проверки, что коэффициент масштабирования равен единице), и поэтому практически не влияет на производительность.

Чтобы увидеть оператор UniformScaling в действии:

julia> U = UniformScaling(2);

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

julia> a + U
2×2 Array{Int64,2}:
 3  2
 3  6

julia> a * U
2×2 Array{Int64,2}:
 2  4
 6  8

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

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

julia> b - U
ERROR: DimensionMismatch("matrix is not square: dimensions are (2, 3)")
Stacktrace:
[...]

Разложения матриц

Разложения матриц (также известные как разложения матриц) вычисляют разложение матрицы в произведение матриц и являются одним из центральных понятий линейной алгебры.

В следующей таблице обобщены типы разложений матриц, реализованные в Julia. Подробности об ассоциированных методах можно найти в разделе «Стандартные функции» документации по линейной алгебре.

Стандартные функции

Функции линейной алгебры в Julia в основном реализуются путём вызова функций из LAPACK. Разложения разреженных матриц используют функции из SuiteSparse.

Base.:*Метод

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

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

Примеры

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

Base.:\Метод

\(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

LinearAlgebra.dotФункция

dot(x, y)
x ⋅ y

Для любых итерируемых контейнеров x и y (включая массивы любой размерности) чисел (или любого типа элементов, для которых определено dot), вычислить скалярное произведение, т.е. сумму dot(x[i],y[i]), как если бы они были векторами.

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

Примеры

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

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

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

julia> dot(x, y)
150.0

dot(x, y)
x ⋅ y

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

Примеры

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

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

LinearAlgebra.crossФункция

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

LinearAlgebra.factorizeФункция

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.

LinearAlgebra.DiagonalТип

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

LinearAlgebra.BidiagonalТип

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

LinearAlgebra.SymTridiagonalТип

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

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

Примеры

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.TridiagonalТип

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

LinearAlgebra.SymmetricТип

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)).

LinearAlgebra.HermitianТип

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)

LinearAlgebra.LowerTriangularТип

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

LinearAlgebra.UpperTriangularТип

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

LinearAlgebra.UniformScalingТип

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

LinearAlgebra.luФункция

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
 1.5  1.0
U factor:
2×2 Array{Float64,2}:
 4.0   3.0
 0.0  -1.5

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

LinearAlgebra.lu!Функция

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(Int64, 0.6666666666666666)
Stacktrace:
[...]

LinearAlgebra.choleskyФункция

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

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

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

Примеры

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

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

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

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

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

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

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

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

LinearAlgebra.cholesky!Функция

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(Int64, 6.782329983125268)
Stacktrace:
[...]

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

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

LinearAlgebra.lowrankupdateФункция

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) операции.

LinearAlgebra.lowrankdowndateФункция

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) операции.

LinearAlgebra.lowrankupdate!Функция

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 уничтожается во время вычислений.

LinearAlgebra.lowrankdowndate!Функция

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 уничтожается во время вычислений.

LinearAlgebra.ldltФункция

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

LinearAlgebra.ldlt!Функция

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

LinearAlgebra.qrФункция

qr(A, pivot=Val(false)) -> 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 прямоугольная, \ вернет решение наименьших квадратов, а если решение не единственное, то вернётся решение с наименьшей нормой.

Разрешено умножение относительно полной/квадратной или неполной/квадратной Q, т.е. поддерживаются как F.Q*F.R, так и F.Q*A. Матрица Q может быть преобразована в обычную матрицу с помощью Matrix.

Примеры

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

LinearAlgebra.qr!Функция

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

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(Int64, -3.1622776601683795)
Stacktrace:
[...]

LinearAlgebra.QRТип

QR <: Factorization

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

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

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

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

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

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

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

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

LinearAlgebra.QRCompactWYТип

QRCompactWY <: Factorization

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

где $Q$ — ортогональная/унитарная матрица, а $R$ — верхняя треугольная матрица. Это похоже на формат QR, за исключением того, что ортогональная/унитарная матрица $Q$ хранится в формате Compact WY [Schreiber1989] как нижняя трапециевидная матрица $V$ и верхняя треугольная матрица $T$, где

таким образом, что $v_i$ — $i$-й столбец матрицы $V$, а $au_i$ — $i$-й диагональный элемент матрицы $T$.

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

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

• factors, как и в типе QR, является матрицей m×n.

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

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

• T — это квадратная матрица с min(m,n) столбцами, верхняя треугольная часть которой задаёт матрицу $T$ выше (элементы под диагональю игнорируются).

LinearAlgebra.QRPivotedТип

QRPivoted <: Factorization

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

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

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

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

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

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

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

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

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

LinearAlgebra.lq!Функция

lq!(A) -> LQ

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

LinearAlgebra.lqФункция

lq(A) -> S::LQ

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

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

Разложение LQ является разложением QR от transpose(A).

Примеры

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

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

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

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

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

LinearAlgebra.bunchkaufmanФункция

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

Вычисление разложения Банча-Кофмана [Bunch1977] матрицы Symmetric или Hermitian 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.

и решения симметричных систем линейных уравнений, Mathematics of Computation 31:137 (1977), 163-179. url.

Примеры

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

julia> S = bunchkaufman(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

LinearAlgebra.bunchkaufman!Функция

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

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

LinearAlgebra.eigvalsФункция

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

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

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

Примеры

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

LinearAlgebra.eigvals!Функция

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

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

Примеры

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) -> 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 — верхняя граница.

LinearAlgebra.eigmaxФункция

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:
[...]

LinearAlgebra.eigminФункция

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:
[...]

LinearAlgebra.eigvecsФункция

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) -> Matrix

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

LinearAlgebra.eigenФункция

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

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

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

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

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

Примеры

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}}
eigenvalues:
3-element Array{Float64,1}:
  1.0
  3.0
 18.0
eigenvectors:
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.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);

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.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.values и собственные векторы в столбцах матрицы F.vectors. (k-й собственный вектор можно получить из среза F.vectors[:, k].)

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

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

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

LinearAlgebra.eigen!Функция

eigen!(A, [B])

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

LinearAlgebra.hessenbergФункция

hessenberg(A) -> Hessenberg

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

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

Примеры

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);

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

LinearAlgebra.hessenberg!Функция

hessenberg!(A) -> Hessenberg

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

LinearAlgebra.schur!Функция

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 в качестве рабочей области.

LinearAlgebra.schurФункция

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.β.

LinearAlgebra.ordschurФункция

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.β.

LinearAlgebra.ordschur!Функция

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

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

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

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

LinearAlgebra.svdФункция

svd(A; full::Bool = false) -> 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) — количество сингулярных значений.

Примеры

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);

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

svd(A, B) -> GeneralizedSVD

Вычислить обобщенное сингулярное разложение (GSVD) A и B, возвращая объект факторизации GeneralizedSVD F, такой что A = F.U*F.D1*F.R0*F.Q' и B = F.V*F.D2*F.R0*F.Q'.

Для матрицы 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);

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

LinearAlgebra.svd!Функция

svd!(A; full::Bool = false) -> SVD

svd! эквивалентна svd, но экономит память, перезаписывая входной параметр 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> F = svd!(A);

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> A
4×5 Array{Float64,2}:
 -2.23607   0.0   0.0  0.0  0.618034
  0.0      -3.0   1.0  0.0  0.0
  0.0       0.0   0.0  0.0  0.0
  0.0       0.0  -2.0  0.0  0.0

svd!(A, B) -> GeneralizedSVD

svd! эквивалентна svd, но изменяет аргументы 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> F = svd!(A, B);

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

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

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

LinearAlgebra.svdvalsФункция

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

LinearAlgebra.svdvals!Функция

svdvals!(A)

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

Примеры

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

julia> A
4×5 Array{Float64,2}:
 -2.23607   0.0   0.0  0.0  0.618034
  0.0      -3.0   1.0  0.0  0.0
  0.0       0.0   0.0  0.0  0.0
  0.0       0.0  -2.0  0.0  0.0

svdvals!(A, B)

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

Примеры

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

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

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

LinearAlgebra.GivensТип

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

LinearAlgebra.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

LinearAlgebra.triuФункция

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

LinearAlgebra.triu!Функция

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

LinearAlgebra.trilФункция

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

LinearAlgebra.tril!Функция

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

LinearAlgebra.diagindФункция

diagind(M, k::Integer=0)

Вектор, содержащий индексы AbstractRange-й диагонали матрицы 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

LinearAlgebra.diagФункция

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

LinearAlgebra.diagmФункция

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

Конструирует квадратную матрицу из векторов диагоналей. Вектор kv.second будет размещён на kv.first диагонали. 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

LinearAlgebra.rankФункция

rank(A[, tol::Real])

Вычисляет ранг матрицы, подсчитывая, сколько сингулярных значений A имеют величину, большую чем tol*σ₁, где σ₁ — наибольшее сингулярное значение A. По умолчанию значение tol — это наименьшая размерность A, умноженная на eps типа eltype элементов A.

Примеры

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

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

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

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

LinearAlgebra.normФункция

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

julia> norm(-2, 1)
2

julia> norm(2, 2)
2

julia> norm(-2, 2)
2

julia> norm(2, Inf)
2

julia> norm(-2, Inf)
2

LinearAlgebra.opnormФункция

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

LinearAlgebra.normalize!Функция

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

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

LinearAlgebra.normalizeФункция

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

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

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

LinearAlgebra.condФункция

cond(M, p::Real=2)

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

LinearAlgebra.condskeelФункция

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 (по умолчанию).

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

LinearAlgebra.trФункция

tr(M)

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

Примеры

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

julia> tr(A)
5

LinearAlgebra.detФункция

det(M)

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

Примеры

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

julia> det(M)
2.0

LinearAlgebra.logdetФункция

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

LinearAlgebra.logabsdetФункция

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)

Base.invМетод

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

LinearAlgebra.pinvФункция

pinv(M[, tol::Real])

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

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

Оптимальный выбор tol зависит как от значения M, так и от предполагаемого применения псевдообратной матрицы. Значение по умолчанию для tol — eps(real(float(one(eltype(M)))))*minimum(size(M)), что по существу является машинной епсилон для вещественной части элемента матрицы, умноженного на большую размерность матрицы. Для инверсии плотных плохо обусловленных матриц в смысле наименьших квадратов рекомендуется tol = 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

LinearAlgebra.nullspaceФункция

nullspace(M[, tol::Real])

Вычисляет базис для нулевого пространства M, включая сингулярные векторы А, у которых сингулярные значения больше, чем tol*σ₁, где σ₁ — это наибольшие сингулярные значения A. По умолчанию значение tol равно наименьшему измерению A, умноженному на eps типа eltype A.

Примеры

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, 2)
3×3 Array{Float64,2}:
 0.0  1.0  0.0
 1.0  0.0  0.0
 0.0  0.0  1.0

Base.kronФункция

kron(A, B)

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

Примеры

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

Base.expМетод

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

Base.logМетод

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

Base.sqrtМетод

sqrt(A::AbstractMatrix)

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

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

Примеры

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

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

Base.cosМетод

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

Base.sinМетод

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

Base.Math.sincosМетод

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

Base.tanМетод

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

Base.Math.secМетод

sec(A::AbstractMatrix)

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

Base.Math.cscМетод

csc(A::AbstractMatrix)

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

Base.Math.cotМетод

cot(A::AbstractMatrix)

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

Base.coshМетод

cosh(A::AbstractMatrix)

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

Base.sinhМетод

sinh(A::AbstractMatrix)

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

Base.tanhМетод

tanh(A::AbstractMatrix)

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

Base.Math.sechМетод

sech(A::AbstractMatrix)

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

Метод

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

Метод

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

Метод

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

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

Примеры

Метод

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

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

Примеры

Метод

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

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

Примеры

Base.Math.asecМетод

asec(A::AbstractMatrix)

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

Base.Math.acscМетод

acsc(A::AbstractMatrix)

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

Base.Math.acotМетод

acot(A::AbstractMatrix)

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

Base.acoshМетод

acosh(A::AbstractMatrix)

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

Base.asinhМетод

asinh(A::AbstractMatrix)

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

Base.atanhМетод

atanh(A::AbstractMatrix)

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

Base.Math.asechМетод

asech(A::AbstractMatrix)

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

Base.Math.acschМетод

acsch(A::AbstractMatrix)

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

Base.Math.acothМетод

acoth(A::AbstractMatrix)

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

LinearAlgebra.lyapФункция

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

LinearAlgebra.sylvesterФункция

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

LinearAlgebra.issuccessФункция

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

LinearAlgebra.issymmetricФункция

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

LinearAlgebra.isposdefФункция

isposdef(A) -> Bool

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

Примеры

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

julia> isposdef(A)
true

LinearAlgebra.isposdef!Функция

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

LinearAlgebra.istrilФункция

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

LinearAlgebra.istriuФункция

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

LinearAlgebra.isdiagФункция

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

LinearAlgebra.ishermitianФункция

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

Base.transposeФункция

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

LinearAlgebra.transpose!Функция

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

Base.adjointФункция

adjoint(A)

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

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

Примеры

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

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

LinearAlgebra.adjoint!Функция

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

Base.copyМетод

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

LinearAlgebra.stride1Функция

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Функция

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

Низкоуровневые операции с матрицами

Во многих случаях существуют операции с матрицами, которые позволяют вам предоставить предварительно выделенный вектор или матрицу результата. Это полезно при оптимизации критического кода, чтобы избежать накладных расходов при многократных выделениях. Эти операции с матрицами дополняются ! (например, mul!) в соответствии с обычной конвенцией Julia.

LinearAlgebra.mul!Функция

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

LinearAlgebra.lmul!Функция

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

Умножает массив B на скаляр a, перезаписывая B на месте.

Примеры

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

lmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывая B, и возвращает результат.

Примеры

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

LinearAlgebra.rmul!Функция

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

Умножает массив A на скаляр b, перезаписывая A на месте.

Примеры

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

rmul!(A, B)

Вычисляет произведение матриц $AB$, перезаписывая A, и возвращает результат.

Примеры

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

LinearAlgebra.ldiv!Функция

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

LinearAlgebra.rdiv!Функция

rdiv!(A, B)

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

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

Функции BLAS

В Julia (как и во многих научных вычислениях) операции с плотной линейной алгеброй основаны на библиотеке LAPACK, которая в свою очередь построена на основе основных блоков линейной алгебры, известных как BLAS. Для каждой компьютерной архитектуры существуют высокооптимизированные реализации BLAS, и иногда в высокопроизводительных процедурах линейной алгебры полезно вызывать функции BLAS напрямую.

LinearAlgebra.BLAS предоставляет обёртки для некоторых функций BLAS. Функции BLAS, которые перезаписывают один из входных массивов, имеют имена, заканчивающиеся на '!'. Обычно функция BLAS имеет четыре метода, определённые для Float64, Float32, ComplexF64 и ComplexF32 массивов.

Символьные аргументы BLAS

Многие функции BLAS принимают аргументы, определяющие, следует ли транспонировать аргумент (trans), какой треугольник матрицы следует использовать (uplo или ul), можно ли считать диагональ треугольной матрицы состоящей из единиц (dA) или на какой стороне матричного умножения должен находиться входной аргумент (side). Возможные значения:

Порядок умножения

Ссылка на треугольник

Операция транспонирования

Единичная диагональ

LinearAlgebra.BLASМодуль

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

LinearAlgebra.BLAS.dotuФункция

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

LinearAlgebra.BLAS.dotcФункция

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

LinearAlgebra.BLAS.blascopy!Функция

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

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

LinearAlgebra.BLAS.nrm2Функция

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

LinearAlgebra.BLAS.asumФункция

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

LinearAlgebra.axpy!Функция

axpy!(a, X, Y)

Перезапись Y значением a*X + 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

LinearAlgebra.BLAS.scal!Функция

scal!(n, a, X, incx)

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

LinearAlgebra.BLAS.scalФункция

scal(n, a, X, incx)

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

LinearAlgebra.BLAS.ger!Функция

ger!(alpha, x, y, A)

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

LinearAlgebra.BLAS.syr!Функция

syr!(uplo, alpha, x, A)

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

LinearAlgebra.BLAS.syrk!Функция

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

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

LinearAlgebra.BLAS.syrkФункция

syrk(uplo, trans, alpha, A)

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

LinearAlgebra.BLAS.her!Функция

her!(uplo, alpha, x, A)

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

LinearAlgebra.BLAS.herk!Функция

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

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

LinearAlgebra.BLAS.herkФункция

herk(uplo, trans, alpha, A)

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

LinearAlgebra.BLAS.gbmv!Функция

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.

LinearAlgebra.BLAS.gbmvФункция

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

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

LinearAlgebra.BLAS.sbmv!Функция

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.

LinearAlgebra.BLAS.sbmvМетод

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

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

LinearAlgebra.BLAS.sbmvМетод

sbmv(uplo, k, A, x)

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

LinearAlgebra.BLAS.gemm!Функция

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

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

LinearAlgebra.BLAS.gemmМетод

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

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

LinearAlgebra.BLAS.gemmМетод

gemm(tA, tB, A, B)

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

LinearAlgebra.BLAS.gemv!Функция

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

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, alpha, A, x)

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, A, x)

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

LinearAlgebra.BLAS.symm!Функция

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

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

LinearAlgebra.BLAS.symmМетод

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

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

LinearAlgebra.BLAS.symmМетод

symm(side, ul, A, B)

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

LinearAlgebra.BLAS.symv!Функция

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

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

LinearAlgebra.BLAS.symvМетод

symv(ul, alpha, A, x)

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

LinearAlgebra.BLAS.symvМетод

symv(ul, A, x)

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

LinearAlgebra.BLAS.trmm!Функция

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

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

LinearAlgebra.BLAS.trmmФункция

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

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

LinearAlgebra.BLAS.trsm!Функция

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

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

LinearAlgebra.BLAS.trsmФункция

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

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

LinearAlgebra.BLAS.trmv!Функция

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

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

LinearAlgebra.BLAS.trmvФункция

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

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

LinearAlgebra.BLAS.trsv!Функция

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

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

LinearAlgebra.BLAS.trsvФункция

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

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

LinearAlgebra.BLAS.set_num_threadsФункция

set_num_threads(n)

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

LinearAlgebra.IКонстанта

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

Функции LAPACK

LinearAlgebra.LAPACK предоставляет обёртки для некоторых функций LAPACK для линейной алгебры. Функции, которые перезаписывают один из входных массивов, имеют имена, заканчивающиеся на '!'.

Обычно для функции определено 4 метода, по одному для массивов Float64, Float32, ComplexF64 и ComplexF32.

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

LinearAlgebra.LAPACKМодуль

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

LinearAlgebra.LAPACK.gbtrf!Функция

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

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

LinearAlgebra.LAPACK.gbtrs!Функция

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

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

LinearAlgebra.LAPACK.gebal!Функция

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 содержит информацию о выполненных масштабировании/перестановках.

LinearAlgebra.LAPACK.gebak!Функция

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

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

LinearAlgebra.LAPACK.gebrd!Функция

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

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

LinearAlgebra.LAPACK.gelqf!Функция

gelqf!(A, tau)

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

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

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

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

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

LinearAlgebra.LAPACK.geqlf!Функция

geqlf!(A, tau)

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

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

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

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

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

LinearAlgebra.LAPACK.geqrf!Функция

geqrf!(A, tau)

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

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

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

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

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

LinearAlgebra.LAPACK.geqp3!Функция

geqp3!(A, jpvt, tau)

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

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

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

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

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

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

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

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

LinearAlgebra.LAPACK.gerqf!Функция

gerqf!(A, tau)

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

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

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

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

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

LinearAlgebra.LAPACK.geqrt!Функция

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

LinearAlgebra.LAPACK.geqrt3!Функция

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

LinearAlgebra.LAPACK.getrf!Функция

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

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

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

LinearAlgebra.LAPACK.tzrzf!Функция

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

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

LinearAlgebra.LAPACK.ormrz!Функция

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

Умножает матрицу C на матрицу Q слева или справа (в зависимости от side или trans), а также может использовать транспонированную (trans = T) или сопряжённо-транспонированную (trans = C) матрицу tzrzf!. Возвращает матрицу C, которая модифицируется на месте результатом умножения.

LinearAlgebra.LAPACK.gels!Функция

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.

LinearAlgebra.LAPACK.gesv!Функция

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

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

LinearAlgebra.LAPACK.getrs!Функция

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).

LinearAlgebra.LAPACK.getri!Функция

getri!(A, ipiv)

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

LinearAlgebra.LAPACK.gesvx!Функция

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

Возвращает решение X; информацию о выравнивании (equed), диагональные элементы выравнивания по строкам (R) и столбцам (C); равновесную матрицу (B); обратную величину условного числа (rcond); границы погрешности (ferr, berr); и коэффициент роста пивотов (work).

gesvx!(A, B)

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

LinearAlgebra.LAPACK.gelsd!Функция

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

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

LinearAlgebra.LAPACK.gelsy!Функция

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

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

LinearAlgebra.LAPACK.gglse!Функция

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

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

LinearAlgebra.LAPACK.geev!Функция

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

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

LinearAlgebra.LAPACK.gesdd!Функция

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' вычисляются и возвращаются отдельно.

LinearAlgebra.LAPACK.gesvd!Функция

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.

LinearAlgebra.LAPACK.ggsvd!Функция

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.

LinearAlgebra.LAPACK.ggsvd3!Функция

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.

LinearAlgebra.LAPACK.geevx!Функция

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, правые и левые собственные векторы должны быть вычислены.

LinearAlgebra.LAPACK.ggev!Функция

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

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

LinearAlgebra.LAPACK.gtsv!Функция

gtsv!(dl, d, du, B)

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

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

LinearAlgebra.LAPACK.gttrf!Функция

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

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

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

LinearAlgebra.LAPACK.gttrs!Функция

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.

LinearAlgebra.LAPACK.orglq!Функция

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

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

LinearAlgebra.LAPACK.orgqr!Функция

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

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

LinearAlgebra.LAPACK.orgql!Функция

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

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

LinearAlgebra.LAPACK.orgrq!Функция

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

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

LinearAlgebra.LAPACK.ormlq!Функция

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 перезаписывается.

LinearAlgebra.LAPACK.ormqr!Функция

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 перезаписывается.

LinearAlgebra.LAPACK.ormql!Функция

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 перезаписывается.

LinearAlgebra.LAPACK.ormrq!Функция

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 перезаписывается.

LinearAlgebra.LAPACK.gemqrt!Функция

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 перезаписывается.

LinearAlgebra.LAPACK.posv!Функция

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

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

LinearAlgebra.LAPACK.potrf!Функция

potrf!(uplo, A)

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

LinearAlgebra.LAPACK.potri!Функция

potri!(uplo, A)

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

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

LinearAlgebra.LAPACK.potrs!Функция

potrs!(uplo, A, B)

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

LinearAlgebra.LAPACK.pstrf!Функция

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

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

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

LinearAlgebra.LAPACK.ptsv!Функция

ptsv!(D, E, B)

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

LinearAlgebra.LAPACK.pttrf!Функция

pttrf!(D, E)

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

LinearAlgebra.LAPACK.pttrs!Функция

pttrs!(D, E, B)

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

LinearAlgebra.LAPACK.trtri!Функция

trtri!(uplo, diag, A)

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

LinearAlgebra.LAPACK.trtrs!Функция

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.

LinearAlgebra.LAPACK.trcon!Функция

trcon!(norm, uplo, diag, A)

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

LinearAlgebra.LAPACK.trevc!Функция

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.

LinearAlgebra.LAPACK.trrfs!Функция

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 — обратная ошибка, покомпонентно.

LinearAlgebra.LAPACK.stev!Функция

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

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

LinearAlgebra.LAPACK.stebz!Функция

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 может быть установлено как допустимая погрешность для сходимости.

LinearAlgebra.LAPACK.stegr!Функция

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.

LinearAlgebra.LAPACK.stein!Функция

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

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

LinearAlgebra.LAPACK.syconv!Функция

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

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

LinearAlgebra.LAPACK.sysv!Функция

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

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

LinearAlgebra.LAPACK.sytrf!Функция

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

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

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

LinearAlgebra.LAPACK.sytri!Функция

sytri!(uplo, A, ipiv)

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

LinearAlgebra.LAPACK.sytrs!Функция

sytrs!(uplo, A, ipiv, B)

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

LinearAlgebra.LAPACK.hesv!Функция

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

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

LinearAlgebra.LAPACK.hetrf!Функция

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

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

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

LinearAlgebra.LAPACK.hetri!Функция

hetri!(uplo, A, ipiv)

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

LinearAlgebra.LAPACK.hetrs!Функция

hetrs!(uplo, A, ipiv, B)

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

LinearAlgebra.LAPACK.syev!Функция

syev!(jobz, uplo, A)

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

LinearAlgebra.LAPACK.syevr!Функция

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.

LinearAlgebra.LAPACK.sygvd!Функция

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.

LinearAlgebra.LAPACK.bdsqr!Функция

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.

LinearAlgebra.LAPACK.bdsdc!Функция

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.

LinearAlgebra.LAPACK.gecon!Функция

gecon!(normtype, A, anorm)

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

LinearAlgebra.LAPACK.gehrd!Функция

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

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

LinearAlgebra.LAPACK.orghr!Функция

orghr!(ilo, ihi, A, tau)

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

LinearAlgebra.LAPACK.gees!Функция

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

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

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

LinearAlgebra.LAPACK.gges!Функция

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

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

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

LinearAlgebra.LAPACK.trexc!Функция

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

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

LinearAlgebra.LAPACK.trsen!Функция

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.

LinearAlgebra.LAPACK.tgsen!Функция

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщённого разложения Шура. select определяет собственные значения в каждом кластере.

LinearAlgebra.LAPACK.trsyl!Функция

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.