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

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

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

julia> tr(A)
3

julia> det(A)
104.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Легенда:

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

Легенда:

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

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

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

julia> U = UniformScaling(2);

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

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

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

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

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

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

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

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

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

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

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

Base.:*Метод

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

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

Примеры

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

Base.:\Метод

\(A, B)

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

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

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

Примеры

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

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

julia> A * X == B
true

LinearAlgebra.dotФункция

dot(x, y)
x ⋅ y

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

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

Примеры

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

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

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

julia> dot(x, y)
150.0

dot(x, y)
x ⋅ y

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

Примеры

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

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

LinearAlgebra.crossФункция

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

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

Примеры

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

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

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

LinearAlgebra.factorizeФункция

factorize(A)

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

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

Примеры

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Array{Float64,2}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorize(A) # factorize will check to see that A is already factorized
5×5 Bidiagonal{Float64,Array{Float64,1}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

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

LinearAlgebra.DiagonalТип

Diagonal(A::AbstractMatrix)

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

Примеры

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

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

Diagonal(V::AbstractVector)

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

Примеры

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

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

LinearAlgebra.BidiagonalТип

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

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

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

Строит Bidiagonal матрицу из главной диагонали A и её первой наддиагонали (если uplo=:U) или поддиагонали (если uplo=:L).

Примеры

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

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

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

LinearAlgebra.SymTridiagonalТип

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

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

Примеры

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.TridiagonalТип

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

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

Примеры

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

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

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

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64,Array{Int64,1}}:
 7  4  ⋅  ⋅
 1  8  5  ⋅
 ⋅  2  9  6
 ⋅  ⋅  3  0

Tridiagonal(A)

Создайте треугольную матрицу из первой побочной диагонали, диагонали и первой наддиагонали матрицы A.

Примеры

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

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

LinearAlgebra.SymmetricТип

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

LinearAlgebra.HermitianТип

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

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

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

LinearAlgebra.LowerTriangularТип

LowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.UpperTriangularТип

UpperTriangular(A::AbstractMatrix)

Создайте представление UpperTriangular матрицы A.

Примеры

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

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

LinearAlgebra.UniformScalingТип

UniformScaling{T<:Number}

Оператор равномерного масштабирования произвольного размера, определённый как скаляр, умноженный на оператор единичной матрицы, λ*I. См. также I.

Примеры

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

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

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

LinearAlgebra.luФункция

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.lu!Функция

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

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

Примеры

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

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

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

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

LinearAlgebra.choleskyФункция

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

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

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

Примеры

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

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

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

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

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

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

Вычислить разложение Холецкого с выбором опорных элементов для плотной симметричной полуопределённой положительно матрицы A и вернуть разложение CholeskyPivoted. Матрица A может быть Symmetric или Hermitian StridedMatrix или совершенно симметричной или эрмитовой StridedMatrix. Треугольный фактор Холецкого можно получить из разложения F с помощью: F.L и F.U. Для объектов 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

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

LinearAlgebra.lowrankupdate!Функция

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

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

LinearAlgebra.lowrankdowndate!Функция

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

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

LinearAlgebra.ldltФункция

ldlt(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt(S);

julia> b = [6., 7., 8.];

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

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

LinearAlgebra.ldlt!Функция

ldlt!(S::SymTridiagonal) -> LDLt

То же, что и ldlt, но экономит место, перезаписывая входные данные S, а не создавая копию.

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

LinearAlgebra.qrФункция

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

LinearAlgebra.qr!Функция

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

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

Примеры

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

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

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

julia> qr!(a)
ERROR: InexactError: Int64(-3.1622776601683795)
Stacktrace:
[...]

LinearAlgebra.QRТип

QR <: Factorization

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

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

Перебирая разложение, получаем компоненты Q и R.

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

• factors — это матрица размера m×n.

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

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

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

LinearAlgebra.QRCompactWYТип

QRCompactWY <: Factorization

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

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

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

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

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

• factors, как и в типе QR, — матрица размера m×n.

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

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

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

LinearAlgebra.QRPivotedТип

QRPivoted <: Factorization

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

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

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

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

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

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

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

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

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

LinearAlgebra.lq!Функция

lq!(A) -> LQ

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

LinearAlgebra.lqФункция

lq(A) -> S::LQ

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.bunchkaufmanФункция

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

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

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

Если rook — true, используется поворот «ладьей». Если rook — false, поворот «ладьей» не используется.

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

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

and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. url.

Примеры

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

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

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

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

LinearAlgebra.bunchkaufman!Функция

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

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

LinearAlgebra.eigvalsФункция

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

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

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

Примеры

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

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

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigvals!Функция

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

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

Примеры

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

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

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

eigvals!(A, B) -> values

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

Примеры

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigmaxФункция

eigmax(A; permute::Bool=true, scale::Bool=true)

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

Примеры

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

julia> eigmax(A)
1.0

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

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

LinearAlgebra.eigminФункция

eigmin(A; permute::Bool=true, scale::Bool=true)

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

Примеры

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

julia> eigmin(A)
-1.0

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

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

LinearAlgebra.eigvecsФункция

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

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

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

Примеры

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

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

julia> eigvecs(A)
3×3 Array{Float64,2}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Array{Float64,2}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

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

LinearAlgebra.eigenФункция

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B) -> GeneralizedEigen

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

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

Примеры

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

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

julia> F = eigen(A, B);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigen!Функция

eigen!(A, [B])

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

LinearAlgebra.hessenbergФункция

hessenberg(A) -> Hessenberg

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

При итерации по разложению получаются факторы F.Q и F.H.

Примеры

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

julia> F = hessenberg(A);

julia> F.Q * F.H * F.Q'
3×3 Array{Float64,2}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # destructuring via iteration

julia> q == F.Q && h == F.H
true

LinearAlgebra.hessenberg!Функция

hessenberg!(A) -> Hessenberg

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

LinearAlgebra.schur!Функция

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

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

Примеры

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

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

julia> A
2×2 Array{Float64,2}:
 3.0   9.0
 0.0  -2.0

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

Аналогично schur, но использует входные матрицы A и B в качестве рабочего пространства.

LinearAlgebra.schurФункция

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

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

При итерации по разложению получаются компоненты F.T, F.Z и F.values.

Примеры

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

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

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

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

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

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

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

При итерации по разложению получаются компоненты F.S, F.T, F.Q, F.Z, F.α и F.β.

LinearAlgebra.ordschurФункция

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

Переупорядочивает разложение Шюра F матрицы A = Z*T*Z' в соответствии с логическим массивом select, возвращая переупорядоченный объект разложения F. Выбранные собственные значения появляются на главной диагонали F.Schur, а соответствующие ведущие столбцы F.vectors образуют ортогональную/унитарную базу соответствующего правого инвариантного подпространства. В вещественном случае, комплексно-сопряжённая пара собственных значений должна быть либо включена, либо исключена через select.

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

Переупорядочивает обобщённое разложение Шюра F пары матриц (A, B) = (Q*S*Z', Q*T*Z') в соответствии с логическим массивом select и возвращает объект GeneralizedSchur F. Выбранные собственные значения появляются на главной диагонали как F.S, так и F.T, и левые и правые ортогональные/унитарные векторы Шюра также переупорядочиваются так, что (A, B) = F.Q*(F.S, F.T)*F.Z' всё ещё выполняется, и обобщённые собственные значения A и B всё ещё можно получить с помощью F.α./F.β.

LinearAlgebra.ordschur!Функция

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

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

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

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

LinearAlgebra.svdФункция

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

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

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

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

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

Примеры

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

julia> F = svd(A);

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

svd(A, B) -> GeneralizedSVD

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

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

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

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

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

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

Примеры

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

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

julia> F = svd(A, B);

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

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

LinearAlgebra.svd!Функция

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

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

Примеры

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

julia> F = svd!(A);

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

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

svd!(A, B) -> GeneralizedSVD

svd! аналогична svd, но изменяет аргументы A и B на месте, вместо создания копий.

Примеры

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

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

julia> F = svd!(A, B);

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

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

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

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

LinearAlgebra.svdvalsФункция

svdvals(A)

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

Примеры

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

julia> svdvals(A)
4-element Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

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

Примеры

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

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

julia> svdvals(A, B)
2-element Array{Float64,1}:
 1.0
 1.0

LinearAlgebra.svdvals!Функция

svdvals!(A)

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

Примеры

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

julia> svdvals!(A)
4-element Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0

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

svdvals!(A, B)

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

Примеры

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

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

julia> svdvals!(A, B)
2-element Array{Float64,1}:
 1.0
 1.0

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

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

LinearAlgebra.GivensТип

LinearAlgebra.Givens(i1,i2,c,s) -> G

Линейный оператор вращения Гивенса. Поля c и s представляют собой косинус и синус угла вращения соответственно. Тип Givens поддерживает левое умножение G*A и сопряженное транспонированное правое умножение A*G'. Тип не имеет size и поэтому может быть умножен на матрицы произвольного размера, при условии, что i2<=size(A,2) для G*A или i2<=size(A,1) для A*G'.

См. также: givens

LinearAlgebra.givensФункция

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

Вычисляет вращение Гивенса G и скаляр r таким образом, что для любого вектора x, где

x[i1] = f
x[i2] = g

результат умножения

y = G*x

обладает свойством

y[i1] = r
y[i2] = 0

См. также: LinearAlgebra.Givens

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

Вычисляет вращение Гивенса G и скаляр r таким образом, что результат умножения

B = G*A

обладает свойством

B[i1,j] = r
B[i2,j] = 0

См. также: LinearAlgebra.Givens

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

Вычисляет вращение Гивенса G и скаляр r таким образом, что результат умножения

B = G*x

обладает свойством

B[i1] = r
B[i2] = 0

См. также: LinearAlgebra.Givens

LinearAlgebra.triuФункция

triu(M)

Верхний треугольник матрицы.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

Возвращает верхний треугольник M, начиная с k-го наддиагонального элемента.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Array{Float64,2}:
 0.0  0.0  0.0  1.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0

julia> triu(a,-3)
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

LinearAlgebra.triu!Функция

triu!(M)

Верхний треугольник матрицы, перезаписывая M в процессе. См. также triu.

triu!(M, k::Integer)

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

Примеры

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

julia> triu!(M, 1)
5×5 Array{Int64,2}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

LinearAlgebra.trilФункция

tril(M)

Нижний треугольник матрицы.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Array{Float64,2}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

Возвращает нижний треугольник M, начиная с k-го наддиагонального элемента.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Array{Float64,2}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

LinearAlgebra.tril!Функция

tril!(M)

Нижний треугольник матрицы, перезаписывая M в процессе. См. также tril.

tril!(M, k::Integer)

Возвращает нижний треугольник M, начиная с k-го наддиагонального элемента, перезаписывая M в процессе.

Примеры

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

julia> tril!(M, 2)
5×5 Array{Int64,2}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

LinearAlgebra.diagindФункция

diagind(M, k::Integer=0)

Возвращает индексы AbstractRange-ой диагонали матрицы M.

Примеры

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

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

LinearAlgebra.diagФункция

diag(M, k::Integer=0)

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

См. также: diagm

Примеры

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

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

LinearAlgebra.diagmФункция

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

Построение квадратной матрицы из диагоналей и векторов. Вектор kv.second будет помещен на kv.first диагональ. diagm строит полную матрицу; для эффективного хранения и быстрых вычислений см. Diagonal, Bidiagonal, Tridiagonal и SymTridiagonal.

Примеры

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

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

LinearAlgebra.rankФункция

rank(A::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

julia> norm(-2, 1)
2

julia> norm(2, 2)
2

julia> norm(-2, 2)
2

julia> norm(2, Inf)
2

julia> norm(-2, Inf)
2

LinearAlgebra.opnormФункция

opnorm(A::AbstractMatrix, p::Real=2)

Вычислить операторную норму (или матричную норму), индуцированную вектором p-нормы, где допустимые значения p — 1, 2 или Inf. (Обратите внимание, что для разреженных матриц p=2 в настоящее время не реализовано.) Используйте norm для вычисления нормы Фробениуса.

При p=1 операторная норма — это максимальная абсолютная сумма столбцов A:

где $a_{ij}$ — элементы $A$, а $m$ и $n$ — его размерности.

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

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

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

LinearAlgebra.normalize!Функция

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

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

LinearAlgebra.normalizeФункция

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

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

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

LinearAlgebra.condФункция

cond(M, p::Real=2)

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

LinearAlgebra.condskeelФункция

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

Число обусловленности по Скилу $\kappa_S$ матрицы M, необязательно относительно вектора x, вычисленное с использованием операторной p-нормы. $\left\vert M \right\vert$ обозначает матрицу из (поэлементных) абсолютных значений $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Допустимые значения для p — 1, 2 и Inf (по умолчанию).

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

LinearAlgebra.trФункция

tr(M)

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

Примеры

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

julia> tr(A)
5

LinearAlgebra.detФункция

det(M)

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

Примеры

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

julia> det(M)
2.0

LinearAlgebra.logdetФункция

logdet(M)

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

Примеры

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

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

LinearAlgebra.logabsdetФункция

logabsdet(M)

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

Примеры

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

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

Base.invМетод

inv(M)

Обратная матрица. Вычисляет матрицу N, такую что M * N = I, где I — единичная матрица. Вычисляется путём решения левого деления N = M \ I.

Примеры

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

julia> N = inv(M)
2×2 Array{Float64,2}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

LinearAlgebra.pinvФункция

pinv(M; 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)

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

Примеры

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

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

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

Base.expМетод

exp(A::AbstractMatrix)

Вычисление матричной экспоненты A, определённой как

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

Примеры

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

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

Base.:^Метод

^(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-5.55112e-17im  0.1-2.77556e-17im
 -0.2+2.498e-16im    0.3-3.46945e-16im

Base.asinМетод

asin(A::AbstractMatrix)

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

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

Примеры

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

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.

Base.Math.acscМетод

acsc(A::AbstractMatrix)

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

Base.Math.acotМетод

acot(A::AbstractMatrix)

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

Base.acoshМетод

acosh(A::AbstractMatrix)

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

Base.asinhМетод

asinh(A::AbstractMatrix)

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

Base.atanhМетод

atanh(A::AbstractMatrix)

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

Base.Math.asechМетод

asech(A::AbstractMatrix)

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

Base.Math.acschМетод

acsch(A::AbstractMatrix)

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

Base.Math.acothМетод

acoth(A::AbstractMatrix)

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

LinearAlgebra.lyapФункция

lyap(A, C)

Вычисляет решение X для непрерывного уравнения Лиувилля AX + XA' + C = 0, где ни один собственный корень A не имеет нулевой действительной части, и ни две собственные точки не являются комплексно сопряжёнными отрицательными.

Примеры

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

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

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

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

LinearAlgebra.sylvesterФункция

sylvester(A, B, C)

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

Примеры

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

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

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

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

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

LinearAlgebra.issuccessФункция

issuccess(F::Factorization)

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

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

julia> LinearAlgebra.issuccess(F)
true

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

julia> LinearAlgebra.issuccess(F)
false

LinearAlgebra.issymmetricФункция

issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

LinearAlgebra.isposdefФункция

isposdef(A) -> Bool

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

Примеры

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

julia> isposdef(A)
true

LinearAlgebra.isposdef!Функция

isposdef!(A) -> Bool

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

Примеры

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Array{Float64,2}:
 1.0  2.0
 2.0  6.78233

LinearAlgebra.istrilФункция

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

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

Примеры

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(b)
true

julia> istril(b, -1)
false

LinearAlgebra.istriuФункция

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

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

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(b)
true

julia> istriu(b, 1)
false

LinearAlgebra.isdiagФункция

isdiag(A) -> Bool

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

LinearAlgebra.ishermitianФункция

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

Base.transposeФункция

transpose(A)

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

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

Примеры

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

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

LinearAlgebra.transpose!Функция

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

Base.adjointФункция

adjoint(A)

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

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

Примеры

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

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

LinearAlgebra.adjoint!Функция

adjoint!(dest,src)

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

Примеры

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

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

julia> adjoint!(B, A);

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

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

Base.copyМетод

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

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

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

Примеры

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

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

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

LinearAlgebra.stride1Функция

stride1(A) -> Int

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

Примеры

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Array{Int64,1}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquareФункция

LinearAlgebra.checksquare(A)

Проверяет, является ли матрица квадратной, а затем возвращает её общую размерность. Для нескольких аргументов возвращает вектор.

Примеры

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Array{Int64,1}:
 4
 5

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

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 и возвращая результат.

Примеры

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

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

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

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

LinearAlgebra.rmul!Функция

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

Умножает массив A на скаляр b, перезаписывая A на месте. Используйте 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 и возвращая результат.

Примеры

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

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

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

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

LinearAlgebra.ldiv!Функция

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

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

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

Примеры

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

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

julia> Y = zero(X);

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

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

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

ldiv!(A, B)

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

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

Примеры

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

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

julia> Y = copy(X);

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

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

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

LinearAlgebra.rdiv!Функция

rdiv!(A, B)

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

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

Функции BLAS

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

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

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

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

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

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

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

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

LinearAlgebra.BLASМодуль

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

nrm2(n, X, incx)

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

Примеры

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

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

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

asum(n, X, incx)

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

Примеры

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

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

LinearAlgebra.axpy!Функция

axpy!(a, X, Y)

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

Примеры

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

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

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

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

scal!(n, a, X, incx)

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

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

scal(n, a, X, incx)

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

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

ger!(alpha, x, y, A)

Обновление матрицы A по формуле ранга 1 векторами x и y.

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

syr!(uplo, alpha, x, A)

Обновление симметричной матрицы A по формуле ранга 1 вектором x. uplo управляет тем, какой треугольник A будет обновлён. Возвращает A.

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

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

Приведение симметричной матрицы C к рангу k как 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 к рангу 1 с вектором x как alpha*x*x' + A. uplo управляет обновлением треугольника A. Возвращает A.

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

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.BLAS.sbmvМетод

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

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

LinearAlgebra.BLAS.sbmvМетод

sbmv(uplo, k, A, x)

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

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

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

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

LinearAlgebra.BLAS.gemmМетод

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

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

LinearAlgebra.BLAS.gemmМетод

gemm(tA, tB, A, B)

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

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

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

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, alpha, A, x)

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, A, x)

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

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

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

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

LinearAlgebra.BLAS.symmМетод

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

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

LinearAlgebra.BLAS.symmМетод

symm(side, ul, A, B)

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

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

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

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

LinearAlgebra.BLAS.symvМетод

symv(ul, alpha, A, x)

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

LinearAlgebra.BLAS.symvМетод

symv(ul, A, x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_num_threads(n)

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

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

I

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

Примеры

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

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

Функции LAPACK

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

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

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

LinearAlgebra.LAPACKМодуль

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

geqp3!(A, jpvt, tau)

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

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

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

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

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

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

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

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

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

gerqf!(A, tau)

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

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

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

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

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

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

geqrt!(A, T)

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

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

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

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

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

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

geqrt3!(A, T)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Умножает матрицу C на Q слева или справа (в зависимости от side или trans), при этом 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 может быть (без изменений), транспонированной, или сопряжённо-транспонированной. 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 может быть (без изменений), транспонированной, или сопряжённо-транспонированной.

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

getri!(A, ipiv)

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

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

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

Решает линейное уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T), или adjoint(A) * X = B (trans = C) с использованием LU факторизации A. fact может быть E, в таком случае A будет сбалансирован и скопирован в AF; F, в таком случае AF и ipiv из предыдущей LU факторизации являются входными данными; или N, в таком случае A будет скопирован в AF и затем факторизован. Если fact = F, equed может быть N, что означает A не сбалансирована; R, что означает A была умножена на Diagonal(R) слева; C, что означает A была умножена на Diagonal(C) справа; или B, что означает A была умножена на Diagonal(R) слева и Diagonal(C) справа. Если fact = F и equed = R или B, элементы R должны быть положительными. Если fact = F и equed = C или B, элементы C должны быть положительными.

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

gesvx!(A, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gtsv!(dl, d, du, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

potrf!(uplo, A)

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

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

potri!(uplo, A)

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

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

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

potrs!(uplo, A, B)

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

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

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

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

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

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

ptsv!(D, E, B)

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

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

pttrf!(D, E)

Вычисляет 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.