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

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

SingularException

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

LinearAlgebra.PosDefExceptionТип

PosDefException

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

LinearAlgebra.dotФункция

dot(x, y)
x ⋅ y

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

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

Примеры

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

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

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

julia> dot(x, y)
150.0

dot(x, y)
x ⋅ y

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

Примеры

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

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

LinearAlgebra.crossФункция

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

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

Примеры

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

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

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

LinearAlgebra.factorizeФункция

factorize(A)

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

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

Примеры

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

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

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

LinearAlgebra.DiagonalТип

Diagonal(A::AbstractMatrix)

Создаёт матрицу из диагональных элементов A.

Примеры

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

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

Diagonal(V::AbstractVector)

Создаёт матрицу с V в качестве диагонали.

Примеры

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

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

LinearAlgebra.BidiagonalТип

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

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

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

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

Примеры

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

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

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

LinearAlgebra.SymTridiagonalТип

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

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

Примеры

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.TridiagonalТип

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

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

Примеры

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

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

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

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

Tridiagonal(A)

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

Примеры

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

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

LinearAlgebra.SymmetricТип

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

LinearAlgebra.HermitianТип

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

Все недействительные части диагонали будут игнорироваться.

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

LinearAlgebra.LowerTriangularТип

LowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.UpperTriangularТип

UpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

LinearAlgebra.UnitLowerTriangularТип

UnitLowerTriangular(A::AbstractMatrix)

Создать UnitLowerTriangular представление матрицы A. Такое представление имеет oneunit типа eltype A на своей диагонали.

Примеры

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

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

LinearAlgebra.UnitUpperTriangularТип

UnitUpperTriangular(A::AbstractMatrix)

Создать UnitUpperTriangular представление матрицы A. Такое представление имеет oneunit типа eltype A на своей диагонали.

Примеры

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

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

LinearAlgebra.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) для объекта F.

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

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

LinearAlgebra.QRCompactWYТип

QRCompactWY <: Factorization

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

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

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

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

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

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

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

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

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

LinearAlgebra.QRPivotedТип

QRPivoted <: Factorization

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

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

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

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

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

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

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

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

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

LinearAlgebra.lq!Функция

lq!(A) -> LQ

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

LinearAlgebra.lqФункция

lq(A) -> S::LQ

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

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

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

Примеры

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

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

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

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

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

LinearAlgebra.bunchkaufmanФункция

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

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

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

Если rook — true, используется поворот Рука. Если rook — false, поворот Рука не используется.

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

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

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

Примеры

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

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

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

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

LinearAlgebra.bunchkaufman!Функция

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

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

LinearAlgebra.eigvalsФункция

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

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

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

Примеры

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

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

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

Пример

julia> eigvals(-2)
-2

eigvals(A, B) -> values

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigvals!Функция

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigmaxФункция

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

LinearAlgebra.eigminФункция

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

LinearAlgebra.eigvecsФункция

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

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

LinearAlgebra.eigenФункция

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

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B) -> GeneralizedEigen

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

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

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

Примеры

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

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

julia> F = eigen(A, B);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.eigen!Функция

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

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

LinearAlgebra.hessenbergФункция

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

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

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

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

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

Итерация по декомпозиции производит компоненты U, V, Q, D1, D2, и R0.

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

Примеры

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

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

julia> F = svd(A, B);

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

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

LinearAlgebra.svd!Функция

svd!(A; full::Bool = false) -> 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}...)

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

Примеры

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

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

diagm(v::AbstractVector)

Конструирует квадратную матрицу с элементами вектора как диагональными элементами.

Примеры

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

LinearAlgebra.rankФункция

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

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

Примеры

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

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

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

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

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

LinearAlgebra.normФункция

norm(A, p::Real=2)

Для любого итерируемого контейнера A (включая массивы любой размерности) чисел (или любого типа элементов, для которых определена norm) вычислите норму p (по умолчанию p=2) так, как если бы A был вектором соответствующей длины.

Норма p определяется как

где $a_i$ — элементы $A$, $| a_i |$ — norm от $a_i$, а $n$ — длина $A$. Поскольку норма p вычисляется с помощью norm элементов A, норма p вектора векторов несовместима с интерпретацией его как блока векторов, вообще говоря, если p != 2.

p может принимать любое числовое значение (хотя не все значения дают математически корректную норму вектора). В частности, norm(A, Inf) возвращает наибольшее значение в abs.(A), а norm(A, -Inf) — наименьшее. Если A является матрицей и p=2, то это эквивалентно норме Фробениуса.

Второй аргумент p не обязательно является частью интерфейса для norm, т.е. пользовательский тип может реализовывать только norm(A) без второго аргумента.

Используйте opnorm для вычисления операторной нормы матрицы.

Примеры

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

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

Для чисел возвращает $\left( |x|^p \right)^{1/p}$.

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

LinearAlgebra.opnormФункция

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

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

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

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

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

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

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

Для обёрнутых векторов 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) == 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

Метод

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

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

Примеры

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

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

Примеры

Метод

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

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

Примеры

Метод

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

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

Примеры

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Метод

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

Функция

Вычисляет решение 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

Функция

Вычисляет решение 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

Функция

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

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

Функция

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

Примеры

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

Функция

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

Примеры

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

julia> isposdef(A)
true

Функция

Проверка, является ли матрица положительно определённой (и эрмитовой) путём попытки выполнения факторизации Холецкого 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

Функция

Проверка, является ли 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

Функция

Проверка, является ли 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

Функция

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

LinearAlgebra.ishermitianФункция

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

Base.transposeФункция

transpose(A)

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

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

Примеры

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

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

LinearAlgebra.transpose!Функция

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

LinearAlgebra.TransposeТип

Transpose

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

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

Примеры

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

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

Base.adjointФункция

adjoint(A)

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

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

Примеры

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

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

LinearAlgebra.adjoint!Функция

adjoint!(dest,src)

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

Примеры

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

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

julia> adjoint!(B, A);

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

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

LinearAlgebra.AdjointТип

Adjoint

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

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

Примеры

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

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

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

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

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

Примеры

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

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

LinearAlgebra.rdiv!Функция

rdiv!(A, B)

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

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

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

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

Примеры

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

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

Функции BLAS

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

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

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

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

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

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

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

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

LinearAlgebra.BLASМодуль

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

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

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

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

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

ger!(alpha, x, y, A)

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

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

syr!(uplo, alpha, x, A)

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

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

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

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

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

syrk(uplo, trans, alpha, A)

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

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

her!(uplo, alpha, x, A)

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

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

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

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

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

herk(uplo, trans, alpha, A)

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

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

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

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

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

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

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

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

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

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

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

LinearAlgebra.BLAS.sbmvМетод

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

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

LinearAlgebra.BLAS.sbmvМетод

sbmv(uplo, k, A, x)

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

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

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

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

LinearAlgebra.BLAS.gemmМетод

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

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

LinearAlgebra.BLAS.gemmМетод

gemm(tA, tB, A, B)

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

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

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

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, alpha, A, x)

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

LinearAlgebra.BLAS.gemvМетод

gemv(tA, A, x)

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

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

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

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

LinearAlgebra.BLAS.symmМетод

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

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

LinearAlgebra.BLAS.symmМетод

symm(side, ul, A, B)

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

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

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

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

LinearAlgebra.BLAS.symvМетод

symv(ul, alpha, A, x)

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

LinearAlgebra.BLAS.symvМетод

symv(ul, A, x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_num_threads(n)

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

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

I

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

Примеры

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

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

Функции LAPACK

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

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

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

LinearAlgebra.LAPACKМодуль

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

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

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

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

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

geqlf!(A, tau)

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

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

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

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

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

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

geqrf!(A, tau)

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

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

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

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

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

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

geqp3!(A, jpvt, tau)

Вычислить факторизацию с пивот-операциями QR A, AP = QR с использованием уровня 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 = 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) с применением преобразования, заданного tzrzf!. Матрица Q может быть не изменённой (trans = N), транспонированной (trans = T) или сопряжённо-транспонированной (trans = C). Возвращает матрицу C, которая изменяется на месте с результатом умножения.

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

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

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

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

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

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

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

getrs!(trans, A, ipiv, B)

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

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

getri!(A, ipiv)

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

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

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

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

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

gesvx!(A, B)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gesdd!(job, A) -> (U, S, VT)

Находит сингулярное разложение A, A = U * S * V', используя подход деления и покорения. Если job = A, все столбцы U и строки V' вычисляются. Если job = N, не вычисляются столбцы U или строки V'. Если job = O, A перезаписывается столбцами (тонкой) U и строками (тонкой) V'. Если job = S, столбцы (тонкой) U и строки (тонкой) V' вычисляются и возвращаются по отдельности.

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

gesvd!(jobu, jobvt, A) -> (U, S, VT)

Находит сингулярное разложение A, A = U * S * V'. Если jobu = A, вычисляются все столбцы U. Если jobvt = A, вычисляются все строки V'. Если jobu = N, не вычисляются столбцы U. Если jobvt = N, не вычисляются строки V'. Если jobu = O, A перезаписывается столбцами (тонкой) U. Если jobvt = O, A перезаписывается строками (тонкой) V'. Если jobu = S, столбцы (тонкой) U вычисляются и возвращаются по отдельности. Если jobvt = S, строки (тонкой) V' вычисляются и возвращаются по отдельности. jobu и jobvt не могут быть одновременно O.

Возвращает U, S, и Vt, где S — это сингулярные значения A.

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

ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

Находит обобщенное сингулярное разложение A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. D1 имеет alpha на своей диагонали, а D2 имеет beta на своей диагонали. Если jobu = U, ортогональная/унитарная матрица U вычисляется. Если jobv = V, ортогональная/унитарная матрица V вычисляется. Если jobq = Q, ортогональная/унитарная матрица Q вычисляется. Если jobu, jobv или jobq равна 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 из факторизации 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.