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

В дополнение к (и как часть) поддержки многомерных массивов, 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:
[...]

Если вам нужно решить много систем вида (A+μI)x = b для того же A и различных μ, может быть полезно предварительно вычислить факторизацию Хессенберга F матрицы A с помощью функции hessenberg. Учитывая F, Julia использует эффективный алгоритм для (F+μ*I) \ b (эквивалентно (A+μ*I)x \ b) и связанных операций, таких как вычисление определителя.

Матричные факторизации

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

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

SingularException

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

LinearAlgebra.PosDefExceptionТип

PosDefException

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

LinearAlgebra.dotФункция

dot(x, y)
x ⋅ y

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

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

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

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

Примеры

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

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

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

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

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

julia> dot(x, y)
150.0

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.UnitLowerTriangularТип

UnitLowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.UnitUpperTriangularТип

UnitUpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.UpperHessenbergТип

UpperHessenberg(A::AbstractMatrix)

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

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

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

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

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

Примеры

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

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

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.FactorizationТип

LinearAlgebra.Factorization

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

LinearAlgebra.LUТип

LU <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.CholeskyТип

Cholesky <: Factorization

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

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

Примеры

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

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

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

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

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

LinearAlgebra.CholeskyPivotedТип

CholeskyPivoted

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

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

Примеры

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

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

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. Для объектов CholeskyPivoted доступны следующие функции: 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(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

Вычитание вектора v из факторизации Холецкого C. Если 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

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

LinearAlgebra.LDLtТип

LDLt <: Factorization

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

Примеры

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

julia> F = ldlt(S)
LDLt{Float64,SymTridiagonal{Float64,Array{Float64,1}}}([3.0 0.3333333333333333 0.0; 0.3333333333333333 3.6666666666666665 0.5454545454545455; 0.0 0.5454545454545455 3.909090909090909])

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

LinearAlgebra.LQТип

LQ <: Factorization

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

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

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

Примеры

```jldoctest 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}} с факторами L и 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; # деструктуризация с помощью итерации

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

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

lq!(A) -> LQ

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

LinearAlgebra.BunchKaufmanТип

BunchKaufman <: Factorization

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.bunchkaufmanФункция

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

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

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

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.bunchkaufman!Функция

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

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

LinearAlgebra.EigenТип

Eigen <: Factorization

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

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

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

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}
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

LinearAlgebra.GeneralizedEigenТип

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

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

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

julia> F.vectors
2×2 Array{Complex{Float64},2}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

LinearAlgebra.eigvalsФункция

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

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

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

Примеры

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

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

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigvals!Функция

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

Аналогично eigvals, но экономит память, перезаписывая входную A, вместо создания копии. irange — диапазон индексов собственных значений для поиска (например, 2-е по 8-е собственные значения).

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

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

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, `sortby`) -> Matrix

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

julia> eigvecs(A, B)
2×2 Array{Complex{Float64},2}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

LinearAlgebra.eigenФункция

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

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

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

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

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

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

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}
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.

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

Примеры

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

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

julia> F = eigen(A, B);

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

julia> F.vectors
2×2 Array{Complex{Float64},2}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigen!Функция

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

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

LinearAlgebra.HessenbergТип

Hessenberg <: Factorization

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

LinearAlgebra.hessenbergФункция

hessenberg(A) -> Hessenberg

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

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

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

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

Примеры

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

julia> F = hessenberg(A);

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 <: Factorization

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.GeneralizedSchurТип

GeneralizedSchur <: Factorization

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

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

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

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.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.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 <: Factorization

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.GeneralizedSVDТип

GeneralizedSVD <: Factorization

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

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

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

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

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

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

Примеры

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

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

julia> F = svd(A, B);

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, alg::Algorithm = default_svd_alg(A)) -> SVD

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

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

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

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

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

Примеры

julia> A = [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> u, s, v = F; # destructuring via iteration

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

svd(A, B) -> GeneralizedSVD

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

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

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

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

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

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

Примеры

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

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

julia> F = svd(A, B);

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

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

LinearAlgebra.svd!Функция

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> 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}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

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

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

Примеры

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

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

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

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

Примеры

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

LinearAlgebra.rankФункция

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

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

Примеры

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

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

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

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

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

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

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

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)

Для оболочек «сопряжённого»/«транспонированного» вектора возвращает операторную $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) == 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; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0

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

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

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

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

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

Примеры

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

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

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

LinearAlgebra.nullspaceФункция

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

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

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

Примеры

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

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

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

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

Base.kronФункция

kron(A, B)

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

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

Примеры

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

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

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

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

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

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

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.:^Метод

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

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

Примеры

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

Base.:^Метод

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

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

Примеры

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

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

Base.logМетод

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

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

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

Примеры

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

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

Base.sqrtМетод

sqrt(A::AbstractMatrix)

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

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

Примеры

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

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

Base.cosМетод

cos(A::AbstractMatrix)

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

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

Примеры

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

Base.sinМетод

sin(A::AbstractMatrix)

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

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

Примеры

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

Base.Math.sincosМетод

sincos(A::AbstractMatrix)

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

Примеры

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Array{Float64,2}:
 0.454649  0.454649
 0.454649  0.454649

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

Base.tanМетод

tan(A::AbstractMatrix)

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

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

Примеры

julia> tan(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
 -1.09252  -1.09252
 -1.09252  -1.09252

Base.Math.secМетод

sec(A::AbstractMatrix)

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

Base.Math.cscМетод

csc(A::AbstractMatrix)

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

Base.Math.cotМетод

cot(A::AbstractMatrix)

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

Base.coshМетод

cosh(A::AbstractMatrix)

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

Base.sinhМетод

sinh(A::AbstractMatrix)

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

Base.tanhМетод

tanh(A::AbstractMatrix)

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

Base.Math.sechМетод

sech(A::AbstractMatrix)

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

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-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-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

Base.atanМетод

atan(A::AbstractMatrix)

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

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

Примеры

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

Base.Math.asecМетод

asec(A::AbstractMatrix)

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

LinearAlgebra.TransposeТип

Transpose

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

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

Примеры

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

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

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

LinearAlgebra.AdjointТип

Adjoint

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

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

Примеры

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

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

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

LinearAlgebra.peakflopsФункция

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

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

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

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

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

Реализация

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

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

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

Примеры

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

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

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

LinearAlgebra.lmul!Функция

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

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

Примеры

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

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

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

lmul!(A, B)

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

Примеры

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

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

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

julia> B
2×2 Array{Int64,2}:
 2  1
 3  0

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

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Array{Float64,2}:
 3.0  4.0
 1.0  2.0

LinearAlgebra.rmul!Функция

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

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

Примеры

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

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

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

rmul!(A, B)

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

Примеры

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

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

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

julia> A
2×2 Array{Int64,2}:
 0  3
 1  2

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

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Array{Float64,2}:
 2.0  1.0
 4.0  3.0

LinearAlgebra.ldiv!Функция

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

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

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

Примеры

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

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

julia> Y = zero(X);

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

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

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

ldiv!(A, B)

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

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

Примеры

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

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

julia> Y = copy(X);

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

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

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

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

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

Примеры

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

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

LinearAlgebra.rdiv!Функция

rdiv!(A, B)

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

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

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

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

Примеры

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

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

Функции BLAS

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

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

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

Примеры

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

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

axpby!(a, X, b, Y)

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

Примеры

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

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

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

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

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

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

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

ger!(alpha, x, y, A)

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

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

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

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

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

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

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

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

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

gerqf!(A, tau)

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

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

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

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

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

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

geqrt!(A, T)

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

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

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

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

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

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

geqrt3!(A, T)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pttrs!(D, E, B)

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

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

trtri!(uplo, diag, A)

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

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

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

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

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

trcon!(norm, uplo, diag, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sytri!(uplo, A, ipiv)

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

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

sytrs!(uplo, A, ipiv, B)

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

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

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

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

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

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

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

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

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

hetri!(uplo, A, ipiv)

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

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

hetrs!(uplo, A, ipiv, B)

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

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

syev!(jobz, uplo, A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gecon!(normtype, A, anorm)

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

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

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

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

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

orghr!(ilo, ihi, A, tau)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает T, Q, переупорядоченные собственные значения в w, числовую характеристику кластера собственных значений s и числовую характеристику инвариантного подпространства sep.

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

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

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

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

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

Решает уравнение Сильвестра для матриц A * X +/- X * B = scale*C, где A и B — квазиверхнетреугольные матрицы. Если transa = N, A не изменяется. Если transa = T, A транспонируется. Если transa = C, A транспонируется сопряженно. Аналогично для transb и B. Если isgn = 1, решается уравнение A * X + X * B = scale * C. Если isgn = -1, решается уравнение A * X - X * B = scale * C.

Возвращает X (заменяя C) и scale.