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

Помимо (и как часть) поддержки многомерных массивов, Julia предоставляет собственные реализации многих общих и полезных операций линейной алгебры, которые могут быть загружены с помощью using LinearAlgebra. Поддерживаются базовые операции, такие как 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, вводя \cdot в 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, \ вернёт решение наименьших квадратов, и если решение не единственное, то вернётся то, у которого норма минимальна. Когда A не полная ранг, требуется факторизация с поворотом (по столбцам), чтобы получить решение минимальной нормы.

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

Для матрицы $M \times N$ A и матрицы $P \times N$ B:

• U — ортогональная матрица $M \times M$,
• V — ортогональная матрица $P \times P$,
• Q — ортогональная матрица $N \times N$,
• D1 — диагональная матрица $M \times (K+L)$ с 1 в первых $K$ элементах,
• D2 — матрица $P \times (K+L)$ с диагональной верхней правой $L \times L$ блочной матрицей,
• R0 — матрица $(K+L) \times N$ с невырожденной верхней треугольной $(K+L) \times (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, дающая индексы k-ой диагонали матрицы M.

Примеры

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

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

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

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

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

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

Оптимальный выбор rtol зависит как от значения M, так и от предполагаемого применения псевдообратной матрицы. Значение rtol по умолчанию равно eps(real(float(one(eltype(M)))))*minimum(size(M)), что по существу соответствует машинной эпсилон для вещественной части элемента матрицы, умноженного на большую размерность матрицы. Для обращения плохо обусловленных плотных матриц в смысле метода наименьших квадратов рекомендуется rtol = sqrt(eps(real(float(one(eltype(M)))))).

Для получения дополнительной информации см. [issue8859], [B96], [S84], [KY88].

Примеры

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

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

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

LinearAlgebra.nullspaceФункция

nullspace(M[, rtol::Real])

Вычисляет базис для нулевого пространства M, включая сингулярные векторы A, модули сингулярных значений которых больше, чем rtol*σ₁, где σ₁ — наибольшее сингулярное значение A. По умолчанию значение rtol равно наименьшей размерности 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

Метод

Если у 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

Метод

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

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

Примеры

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

Метод

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

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

Примеры

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

Метод

Вычислите синус и косинус матрицы квадратной матрицы 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

Метод

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

Base.Math.cschМетод

csch(A::AbstractMatrix)

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

Base.Math.cothМетод

coth(A::AbstractMatrix)

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

Base.acosМетод

acos(A::AbstractMatrix)

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

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

Примеры

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Array{Complex{Float64},2}:
  0.5-5.55112e-17im  0.1-2.77556e-17im
 -0.2+2.498e-16im    0.3-3.46945e-16im

Base.asinМетод

asin(A::AbstractMatrix)

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

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

Примеры

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

Обработка метода

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

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

Примеры

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

Обработка метода

asec(A::AbstractMatrix)

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

Обработка метода

acsc(A::AbstractMatrix)

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

Обработка метода

acot(A::AbstractMatrix)

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

Обработка метода

acosh(A::AbstractMatrix)

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

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

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

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

Примеры

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 "in-place".

Примеры

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 "in-place" и сохраняет результат в 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)

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

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

syr!(uplo, alpha, x, A)

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

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

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

Обновление симметричной матрицы 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)

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

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

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

Только для комплексных массивов. Обновление эрмитовой матрицы 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-разложение на месте и 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 на месте.

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, используя уровень 3 BLAS. P — матрица поворотов, представленная jpvt. tau хранит элементарные отражатели. jpvt должен иметь длину, большую или равную n, если A — матрица (m x n). tau должен иметь длину, большую или равную наименьшей размерности A.

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

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

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

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

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

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

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

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

gesvx!(A, B)

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

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. Если 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)

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

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

pttrs!(D, E, B)

Решает A * X = B для положительно определённой трёхдиагональной A матрицы с диагональю D и внедиагональю E после вычисления LDL^T разложения 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.