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

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

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

Base.:*Метод

*(x, y...)

Оператор умножения. x*y*z*... вызывает эту функцию со всеми аргументами, т.е. *(x, y, z, ...).

Base.:\Метод

\(x, y)

Оператор левого деления: умножение y на обратную матрицу x слева. Для целочисленных аргументов даёт результаты с плавающей точкой.

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [1 2; 3 4]; x = [5, 6];

julia> A \ x
2-element Array{Float64,1}:
 -4.0
  4.5

julia> inv(A) * x
2-element Array{Float64,1}:
 -4.0
  4.5

Base.LinAlg.dotФункция

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

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

Пример:

julia> dot(10, ones(10), 1, ones(20), 2)
10.0

Base.LinAlg.vecdotФункция

vecdot(x, y)

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

Примеры

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

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

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

julia> vecdot(x, y)
150.0

Base.LinAlg.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

Base.LinAlg.factorizeФункция

factorize(A)

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

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

Пример

julia> A = Array(Bidiagonal(ones(5, 5), true))
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}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

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

Base.LinAlg.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}:
 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}:
 1  ⋅
 ⋅  2

Base.LinAlg.BidiagonalТип

Bidiagonal(dv, ev, isupper::Bool)

Создаёт верхнюю (isupper=true) или нижнюю (isupper=false) бидиагональную матрицу, используя заданные векторы диагонали (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, true) # ev is on the first superdiagonal
4×4 Bidiagonal{Int64}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

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

Bidiagonal(dv, ev, uplo::Char)

Создаёт верхнюю (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') #e is on the first superdiagonal
4×4 Bidiagonal{Int64}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

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

Bidiagonal(A, isupper::Bool)

Создаёт Bidiagonal матрицу из главной диагонали A и её первого наддиагонального (если isupper=true) или поддиагонального (если isupper=false).

Пример

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, true) #contains the main diagonal and first superdiagonal of A
4×4 Bidiagonal{Int64}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

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

Base.LinAlg.SymTridiagonalТип

SymTridiagonal(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}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

Base.LinAlg.TridiagonalТип

Tridiagonal(dl, d, du)

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

Пример

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

julia> du = [4; 5; 6]
3-element Array{Int64,1}:
 4
 5
 6

julia> d = [7; 8; 9; 0]
4-element Array{Int64,1}:
 7
 8
 9
 0

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

Tridiagonal(A)

возвращает массив Tridiagonal, основанный на (абстрактной) матрице 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}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Base.LinAlg.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 == A.').

Base.LinAlg.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 == A').

Base.LinAlg.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

Base.LinAlg.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

Base.LinAlg.luФункция

lu(A, pivot=Val{true}) -> L, U, p

Вычисляет LU-разложение A, такое что A[p,:] = L*U. По умолчанию используется пивота. Это можно изменить, передав Val{false} в качестве второго аргумента.

См. также lufact.

Пример

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

julia> L, U, p = lu(A)
([1.0 0.0; 0.666667 1.0], [6.0 3.0; 0.0 1.0], [2, 1])

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

Base.LinAlg.lufactФункция

lufact(A::SparseMatrixCSC) -> F::UmfpackLU

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

Для разреженных A с вещественным или комплексным типом элементов, возвращаемый тип F есть UmfpackLU{Tv, Ti}, с Tv = Float64 или Complex128 соответственно и Ti является целочисленным типом (Int32 или Int64).

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

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

F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]

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

• \

• cond

• det

lufact(A [,pivot=Val{true}]) -> F::LU

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

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

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

Взаимосвязь между 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 = lufact(A)
Base.LinAlg.LU{Float64,Array{Float64,2}} with factors L and U:
[1.0 0.0; 1.5 1.0]
[4.0 3.0; 0.0 -1.5]

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

Base.LinAlg.lufact!Функция

lufact!(A, pivot=Val{true}) -> LU

lufact! эквивалентна lufact, но экономит память, перезаписывая входной A, вместо создания копии. Исключение InexactError выбрасывается, если факторизация производит число, не представимое типом элементов A (например, для целочисленных типов).

Base.LinAlg.cholФункция

chol(A) -> U

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

Пример

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

julia> U = chol(A)
2×2 UpperTriangular{Float64,Array{Float64,2}}:
 1.0  2.0
  ⋅   6.78233

julia> U'U
2×2 Array{Float64,2}:
 1.0   2.0
 2.0  50.0

chol(x::Number) -> y

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

Пример

julia> chol(16)
4.0

Base.LinAlg.cholfactФункция

cholfact(A; shift = 0.0, perm = Int[]) -> CHOLMOD.Factor

Вычисляет факторизацию Холецкого разреженной положительно определённой матрицы A. A должна быть матрицей SparseMatrixCSC или представлением Symmetric/Hermitian разрежённой матрицы SparseMatrixCSC. Обратите внимание, что даже если у A нет тега типа, она всё равно должна быть симметричной или эрмитовой. Используется уменьшающая заполнение перестановка. F = cholfact(A) чаще всего используется для решения систем уравнений с F\b, но также определены методы diag, det и logdet для F. Вы также можете извлечь отдельные факторы из F, используя F[:L]. Однако, так как пивота включён по умолчанию, факторизация внутренне представлена как A == P'*L*L'*P с матрицей перестановки P; использование только L без учёта P даст неверные результаты. Чтобы учесть эффекты перестановки, обычно предпочтительнее извлекать "комбинированные" факторы, такие как PtL = F[:PtL] (эквивалент P'*L) и LtP = F[:UP] (эквивалент L'*P).

Установка необязательного ключевого аргумента shift вычисляет факторизацию A+shift*I вместо A. Если аргумент perm не пуст, он должен содержать перестановку 1:size(A,1) задающую порядок (вместо стандартного порядка AMD библиотеки CHOLMOD).

cholfact(A, [uplo::Symbol,] Val{false}) -> Cholesky

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

Пример

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 = cholfact(A)
Base.LinAlg.Cholesky{Float64,Array{Float64,2}} with factor:
[2.0 6.0 -8.0; 0.0 1.0 5.0; 0.0 0.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

cholfact(A, [uplo::Symbol,] Val{true}; tol = 0.0) -> CholeskyPivoted

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

Base.LinAlg.cholfact!Функция

cholfact!(F::Factor, A; shift = 0.0) -> CHOLMOD.Factor

Вычислить факторизацию Холецкого ($LL'$) для A, используя символическую факторизацию F. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если A не имеет тега типа, она должна быть симметричной или эрмитовой.

См. также cholfact.

cholfact!(A, [uplo::Symbol,] Val{false}) -> Cholesky

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

Пример

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

julia> cholfact!(A)
ERROR: InexactError()

cholfact!(A, [uplo::Symbol,] Val{true}; tol = 0.0) -> CholeskyPivoted

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

Base.LinAlg.lowrankupdateФункция

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

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

Base.LinAlg.lowrankdowndateФункция

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

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

Base.LinAlg.lowrankupdate!Функция

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

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

Base.LinAlg.lowrankdowndate!Функция

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

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

Base.LinAlg.ldltfactФункция

ldltfact(A; shift = 0.0, perm=Int[]) -> CHOLMOD.Factor

Вычислить факторизацию $LDL'$ разреженной матрицы A. A должна быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если A не имеет тега типа, она должна быть симметричной или эрмитовой. Используется уменьшающая заполнение перестановка. F = ldltfact(A) чаще всего используется для решения систем уравнений A*x = b с F\b. Возвращаемый объект факторизации F также поддерживает методы diag, det, logdet и inv. Вы можете извлечь отдельные факторы из F с помощью F[:L]. Однако, поскольку перестановка включена по умолчанию, факторизация внутренне представляется как A == P'*L*D*L'*P с матрицей перестановки P; использование только L без учёта P даст неверные результаты. Для включения эффектов перестановки обычно предпочтительнее извлечь «комбинированные» факторы, такие как PtL = F[:PtL] (эквивалент P'*L ) и LtP = F[:UP] (эквивалент L'*P). Полный список поддерживаемых факторов :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

Установка необязательного ключевого аргумента shift вычисляет факторизацию A+shift*I вместо A. Если аргумент perm не пустой, он должен быть перестановкой 1:size(A,1) с заданным порядком (вместо по умолчанию CHOLMOD AMD порядок).

ldltfact(S::SymTridiagonal) -> LDLt

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

Base.LinAlg.ldltfact!Функция

ldltfact!(F::Factor, A; shift = 0.0) -> CHOLMOD.Factor

Вычислить разложение $LDL'$ для A, используя символическое разложение F. A должно быть SparseMatrixCSC или Symmetric/Hermitian представлением SparseMatrixCSC. Обратите внимание, что даже если у A нет тега типа, оно всё равно должно быть симметричным или эрмитовым.

См. также ldltfact.

ldltfact!(S::SymTridiagonal) -> LDLt

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

Base.LinAlg.qrФункция

qr(A, pivot=Val{false}; thin::Bool=true) -> Q, R, [p]

Вычислить (с выбором опоры) QR-разложение A таким образом, что либо A = Q*R либо A[:,p] = Q*R. См. также qrfact. По умолчанию вычисляется тонкое разложение. Обратите внимание, что R не дополняется нулями, когда запрашивается полное Q разложение.

qr(v::AbstractVector) -> w, r

Вычисляет полярное разложение вектора. Возвращает w, единичный вектор в направлении v, и r, норму v.

См. также normalize, normalize! и LinAlg.qr!.

Пример

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

julia> w, r = qr(v)
([0.447214, 0.894427], 2.23606797749979)

julia> w*r == v
true

Base.LinAlg.qr!Функция

LinAlg.qr!(v::AbstractVector) -> w, r

Вычисляет полярное разложение вектора. Вместо возвращения нового вектора, как qr(v::AbstractVector), эта функция изменяет входной вектор v на месте. Возвращает w, единичный вектор в направлении v (это изменение v), и r, норму v.

См. также normalize, normalize! и qr.

Base.LinAlg.qrfactФункция

qrfact(A) -> SPQR.Factorization

Вычислить QR разложение разреженной матрицы A. Используется разделяющее перестановку. Основное применение этого типа — решение задач наименьших квадратов с \. Функция вызывает библиотеку SPQR, а некоторые дополнительные функции из библиотеки обернуты, но не экспортированы.

qrfact(A, pivot=Val{false}) -> F

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

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

• если pivot == Val{true} то F это объект QRPivoted,

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

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

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

• F[:Q]: ортогональная/унитарная матрица Q

• F[:R]: верхняя треугольная матрица R

• F[:p]: вектор перестановок опоры (QRPivoted только)

• F[:P]: матрица перестановок опоры (QRPivoted только)

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

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

Пример

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 = qrfact(A)
Base.LinAlg.QRCompactWY{Float64,Array{Float64,2}} with factors Q and R:
[-0.6 0.0 0.8; -0.8 0.0 -0.6; 0.0 -1.0 0.0]
[-5.0 10.0; 0.0 -1.0]

julia> F[:Q] * F[:R] == A
true

Base.LinAlg.qrfact!Функция

qrfact!(A, pivot=Val{false})

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

Base.LinAlg.QRТип

QR <: Factorization

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

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

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

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

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

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

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

Base.LinAlg.QRCompactWYТип

QRCompactWY <: Factorization

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

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

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

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

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

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

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

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

Base.LinAlg.QRPivotedТип

QRPivoted <: Factorization

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

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

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

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

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

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

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

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

Base.LinAlg.lqfact!Функция

lqfact!(A) -> LQ

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

Base.LinAlg.lqfactФункция

lqfact(A) -> LQ

Вычислить факторизацию LQ A. См. также lq.

Base.LinAlg.lqФункция

lq(A; [thin=true]) -> L, Q

Выполнить факторизацию LQ A таким образом, что A = L*Q. По умолчанию вычисляется тонкая факторизация. Факторизация LQ — это факторизация QR A.'. L не расширяется нулями, если требуется полная Q.

Base.LinAlg.bkfactФункция

bkfact(A, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false) -> BunchKaufman

Вычислить факторизацию Банча—Кофмана [Bunch1977] симметричной или эрмитовой матрицы A и вернуть объект BunchKaufman. uplo указывает, какой треугольник матрицы A следует использовать. Если symmetric равно true, предполагается, что A симметрична. Если symmetric равно false, предполагается, что A эрмитова. Если rook равно true, используется поворот в виде ладьи. Если rook равно false, поворот в виде ладьи не используется. Для объектов BunchKaufman доступны следующие функции: size, \, inv, issymmetric, ishermitian.

Base.LinAlg.bkfact!Функция

bkfact!(A, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false) -> BunchKaufman

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

Base.LinAlg.eigФункция

eig(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> D, V
eig(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> D, V
eig(A, permute::Bool=true, scale::Bool=true) -> D, V

Вычисляет собственные значения (D) и собственные векторы (V) A. См. eigfact для получения подробностей об аргументах irange, vl, и vu (для матриц SymTridiagonal, Hermitian, и Symmetric ) и ключевых аргументах permute и scale. Собственные векторы возвращаются по столбцам.

Пример

julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
([1.0, 3.0, 18.0], [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0])

eig — это обёртка вокруг eigfact, извлекающая все части факторизации в кортеж; по возможности, рекомендуется использовать eigfact.

eig(A, B) -> D, V

Вычисляет обобщённые собственные значения (D) и векторы (V) A относительно B.

eig — это обёртка вокруг eigfact, извлекающая все части факторизации в кортеж; по возможности, рекомендуется использовать eigfact.

Пример

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> eig(A, B)
(Complex{Float64}[0.0+1.0im, 0.0-1.0im], Complex{Float64}[0.0-1.0im 0.0+1.0im; -1.0-0.0im -1.0+0.0im])

Base.LinAlg.eigvalsФункция

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

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

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

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

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

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -2.14005
  1.0
  5.14005

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -2.14005
  1.0
  5.14005

Base.LinAlg.eigvals!Функция

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

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

eigvals!(A, B) -> values

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

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

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

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

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

Base.LinAlg.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:
Stacktrace:
 [1] #eigmax#46(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:238
 [2] eigmax(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:236

Base.LinAlg.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:
Stacktrace:
 [1] #eigmin#47(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:280
 [2] eigmin(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:278

Base.LinAlg.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}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A)
3-element Array{Float64,1}:
 -2.14005
  1.0
  5.14005

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.83205
  4.26351e-17
 -0.5547

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

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

Пример

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

Base.LinAlg.eigfactФункция

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

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

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

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

Пример

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

eigfact(A, B) -> GeneralizedEigen

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

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

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

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

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

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

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

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

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

Base.LinAlg.eigfact!Функция

eigfact!(A, [B])

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

Base.LinAlg.hessfactФункция

hessfact(A) -> Hessenberg

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

Пример

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 = hessfact(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

Base.LinAlg.hessfact!Функция

hessfact!(A) -> Hessenberg

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

Base.LinAlg.schurfactФункция

schurfact(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].

Пример

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

julia> F = schurfact(A)
Base.LinAlg.Schur{Float64,Array{Float64,2}} with factors T and Z:
[2.0 0.801792 6.63509; -8.55988e-11 2.0 8.08286; 0.0 0.0 1.99999]
[0.577351 0.154299 -0.801784; 0.577346 -0.77152 0.267262; 0.577354 0.617211 0.534522]
and values:
Complex{Float64}[2.0+8.28447e-6im, 2.0-8.28447e-6im, 1.99999+0.0im]

julia> F[:vectors] * F[:Schur] * F[:vectors]'
3×3 Array{Float64,2}:
 -2.0  1.0   3.0
  2.0  1.0  -1.0
 -7.0  2.0   7.0

schurfact(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[:alpha]./F[:beta].

Base.LinAlg.schurfact!Функция

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

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

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

То же, что и schurfact, но использует входные матрицы A и B в качестве рабочей области.

Base.LinAlg.schurФункция

schur(A::StridedMatrix) -> T::Matrix, Z::Matrix, λ::Vector

Вычисляет факторизацию Шура матрицы A. Методы возвращают (квази)треугольный фактор Шура T и ортогональные/унитарные векторы Шура Z таким образом, что A = Z*T*Z'. Собственные значения A возвращаются в векторе λ.

См. schurfact.

Пример

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

julia> T, Z, lambda = schur(A)
([2.0 0.801792 6.63509; -8.55988e-11 2.0 8.08286; 0.0 0.0 1.99999], [0.577351 0.154299 -0.801784; 0.577346 -0.77152 0.267262; 0.577354 0.617211 0.534522], Complex{Float64}[2.0+8.28447e-6im, 2.0-8.28447e-6im, 1.99999+0.0im])

julia> Z * T * Z'
3×3 Array{Float64,2}:
 -2.0  1.0   3.0
  2.0  1.0  -1.0
 -7.0  2.0   7.0

schur(A::StridedMatrix, B::StridedMatrix) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector

См. schurfact.

Base.LinAlg.ordschurФункция

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

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

ordschur(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector

Переупорядочивает факторизацию Шура вещественной матрицы A = Z*T*Z' в соответствии с логическим массивом select, возвращая переупорядоченные матрицы T и Z, а также вектор собственных значений λ. Выбранные собственные значения появляются на главной диагонали T, а соответствующие ведущие столбцы Z образуют ортогональную/унитарную базу соответствующего правого инвариантного подпространства. В вещественном случае пара комплексно сопряженных собственных значений должна быть либо включена, либо исключена с помощью 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[:alpha]./F[:beta].

ordschur(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector

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

Base.LinAlg.ordschur!Функция

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

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

ordschur!(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector

То же, что и ordschur, но перезаписывает входные аргументы.

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

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

ordschur!(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector

То же, что и ordschur, но перезаписывает факторизацию входных аргументов.

Base.LinAlg.svdfactФункция

svdfact(A; thin::Bool=true) -> SVD

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

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

Если thin=true (по умолчанию), возвращается тонкое SVD. Для матрицы $M \times N$ A, U является $M \times M$ для полного SVD (thin=false) и $M \times \min(M, N)$ для тонкого 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> F = svdfact(A)
Base.LinAlg.SVD{Float64,Float64,Array{Float64,2}}([0.0 1.0 0.0 0.0; 1.0 0.0 0.0 0.0; 0.0 0.0 0.0 -1.0; 0.0 0.0 1.0 0.0], [3.0, 2.23607, 2.0, 0.0], [-0.0 0.0 … -0.0 0.0; 0.447214 0.0 … 0.0 0.894427; -0.0 1.0 … -0.0 0.0; 0.0 0.0 … 1.0 0.0])

julia> F[:U] * diagm(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

svdfact(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,

• F[:U] является ортогональной матрицей M-на-M,

• F[:V] является ортогональной матрицей P-на-P,

• F[:Q] является ортогональной матрицей N-на-N,

• F[:R0] является матрицей (K+L)-на-N, чье правое (K+L)-на-(K+L) подблочное содержимое является невырожденной верхней блочно-треугольной матрицей,

• F[:D1] является диагональной матрицей M-на-(K+L) с 1-цами в первых K элементах,

• F[:D2] является матрицей P-на-(K+L) с диагональным верхним правым L-на-L подблоком,

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

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

Base.LinAlg.svdfact!Функция

svdfact!(A, thin::Bool=true) -> SVD

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

svdfact!(A, B) -> GeneralizedSVD

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

Base.LinAlg.svdФункция

svd(A; thin::Bool=true) -> U, S, V

Вычисляет SVD от A, возвращая U, вектор S и V, такие что A == U*diagm(S)*V'. Сингулярные значения в S отсортированы по убыванию.

Если thin=true (по умолчанию), возвращается тонкое SVD. Для матрицы $M \times N$ A, U является $M \times M$ для полного SVD (thin=false) и $M \times \min(M, N)$ для тонкого SVD.

svd является обёрткой вокруг svdfact, извлекая все части факторизации SVD в кортеж. Поэтому прямое использование svdfact более эффективно.

Пример

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> U, S, V = svd(A)
([0.0 1.0 0.0 0.0; 1.0 0.0 0.0 0.0; 0.0 0.0 0.0 -1.0; 0.0 0.0 1.0 0.0], [3.0, 2.23607, 2.0, 0.0], [-0.0 0.447214 -0.0 0.0; 0.0 0.0 1.0 0.0; … ; -0.0 0.0 -0.0 1.0; 0.0 0.894427 0.0 0.0])

julia> U*diagm(S)*V'
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) -> U, V, Q, D1, D2, R0

Обёртка вокруг svdfact для извлечения всех частей факторизации в кортеж. Поэтому прямое использование svdfact обычно более эффективно. Функция возвращает обобщённое SVD от A и B, возвращая U, V, Q, D1, D2 и R0, такие что A = U*D1*R0*Q' и B = V*D2*R0*Q'.

Base.LinAlg.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.23607
 2.0
 0.0

svdvals(A, B)

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

Base.LinAlg.GivensТип

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

Base.LinAlg.givensФункция

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

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

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

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

y = G*x

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

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

См. также: LinAlg.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

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

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

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

B = G*x

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

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

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

Base.LinAlg.triuФункция

triu(M)

Верхняя треугольная часть матрицы.

Пример

julia> a = ones(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 = ones(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

Base.LinAlg.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

Base.LinAlg.trilФункция

tril(M)

Нижняя треугольная часть матрицы.

Пример

julia> a = ones(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 = ones(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

Base.LinAlg.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

Base.LinAlg.diagindФункция

diagind(M, k::Integer=0)

Функция, возвращающая индексы Range-й диагонали матрицы 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

Base.LinAlg.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

Base.LinAlg.diagmФункция

diagm(v, k::Integer=0)

Создаёт матрицу, размещая v на k-й диагонали.

Пример

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

Base.LinAlg.scale!Функция

scale!(A, b)
scale!(b, A)

Масштабирует массив A на скаляр b, перезаписывая A на месте.

Если A является матрицей, а b — вектором, то scale!(A,b) масштабирует каждый столбец i матрицы A на b[i] (аналогично A*Diagonal(b)), в то время как scale!(b,A) масштабирует каждую строку i матрицы A на b[i] (аналогично Diagonal(b)*A), снова действуя на месте на A. Если масштабирование приводит к числу, не представимому типом элементов A, например, для целочисленных типов, возникает исключение InexactError.

Пример

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

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

julia> scale!(a,b)
2×2 Array{Int64,2}:
 1  4
 3  8

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

julia> b = [1; 2];

julia> scale!(b,a)
2×2 Array{Int64,2}:
 1  2
 6  8

Base.LinAlg.rankФункция

rank(M[, tol::Real])

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

Пример

julia> rank(eye(3))
3

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

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

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

Base.LinAlg.normФункция

norm(A::AbstractArray, p::Real=2)

Вычислить p-норму вектора или норму оператора матрицы A, по умолчанию 2-норму.

norm(A::AbstractVector, p::Real=2)

Для векторов это эквивалентно vecnorm и равно:

где $a_i$ — элементы $A$, а $n$ — его длина.

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

Пример

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

julia> norm(v)
7.0

julia> norm(v, Inf)
6.0

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

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

Когда 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> norm(A, Inf)
6.0

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

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

norm(A::RowVector, q::Real=2)

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

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

Base.LinAlg.vecnormФункция

vecnorm(A, p::Real=2)

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

p-норма определяется как:

где $a_i$ — элементы $A$, а $n$ — его длина.

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

Пример

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

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

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

Для чисел вернуть $\left( |x|^p \right) ^{1/p}$.

Base.LinAlg.normalize!Функция

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

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

Base.LinAlg.normalizeФункция

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

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

Примеры

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

julia> b = normalize(a)
3-element Array{Float64,1}:
 0.218218
 0.436436
 0.872872

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Array{Float64,1}:
 0.142857
 0.285714
 0.571429

julia> norm(c, 1)
1.0

Base.LinAlg.condФункция

cond(M, p::Real=2)

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

Base.LinAlg.condskeelФункция

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

Число обусловленности Skeel $\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 (по умолчанию).

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

Base.LinAlg.traceФункция

trace(M)

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

Пример

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

julia> trace(A)
5

Base.LinAlg.detФункция

det(M)

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

Пример

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

julia> det(M)
2.0

Base.LinAlg.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(eye(3))
0.0

Base.LinAlg.logabsdetФункция

logabsdet(M)

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

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 == eye(2)
true

Base.LinAlg.pinvФункция

pinv(M[, tol::Real])

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

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

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

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

Пример

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

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

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

Base.LinAlg.nullspaceФункция

nullspace(M)

Базис для пространства нулей 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

Base.repmatФункция

repmat(A, m::Integer, n::Integer=1)

Построение матрицы путём повторения заданной матрицы (или вектора) m раз по измерению 1 и n раз по измерению 2.

Примеры

julia> repmat([1, 2, 3], 2)
6-element Array{Int64,1}:
 1
 2
 3
 1
 2
 3

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

Base.repeatФункция

repeat(A::AbstractArray; inner=ntuple(x->1, ndims(A)), outer=ntuple(x->1, ndims(A)))

Построение массива путём повторения элементов A. i-й элемент inner определяет количество раз, которое должны повторяться отдельные элементы i-го измерения A. i-й элемент outer определяет количество раз, которое должен повторяться срез по i-му измерению A. Если inner или outer опущены, повторение не выполняется.

Примеры

julia> repeat(1:2, inner=2)
4-element Array{Int64,1}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Array{Int64,1}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Array{Int64,2}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

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

blkdiag(A...)

Склеивание матриц по блочно-диагональной схеме. В настоящее время реализовано только для разреженных матриц.

Пример

julia> blkdiag(speye(3), 2*speye(2))
5×5 SparseMatrixCSC{Float64,Int64} with 5 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0
  [4, 4]  =  2.0
  [5, 5]  =  2.0

Base.LinAlg.linregФункция

linreg(x, y)

Выполнение линейной регрессии с использованием обычных наименьших квадратов. Возвращает a и b такие, что a + b*x является наиболее близкой прямой к заданным точкам (x, y), т. е. такие, что квадратная ошибка между y и a + b*x минимизируется.

Примеры:

using PyPlot
x = 1.0:12.0
y = [5.5, 6.3, 7.6, 8.8, 10.9, 11.79, 13.48, 15.02, 17.77, 20.81, 22.0, 22.99]
a, b = linreg(x, y)          # Linear regression
plot(x, y, "o")              # Plot (x, y) points
plot(x, a + b*x)             # Plot line determined by linear regression

См. также:

\, cov, std, mean.

Base.LinAlg.expmФункция

expm(A)

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

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

Пример

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

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

Base.LinAlg.logmФункция

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

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

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

Пример

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

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

Base.LinAlg.sqrtmФункция

sqrtm(A)

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

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

Пример

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

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

Base.LinAlg.lyapФункция

lyap(A, C)

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

Base.LinAlg.sylvesterФункция

sylvester(A, B, C)

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

Base.LinAlg.issymmetricФункция

issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

Base.LinAlg.isposdefФункция

isposdef(A) -> Bool

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

Пример

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

julia> isposdef(A)
true

Base.LinAlg.isposdef!Функция

isposdef!(A) -> Bool

Проверка, является ли матрица положительно определенной, перезаписывая A в процессе.

Пример

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

Base.LinAlg.istrilФункция

istril(A) -> Bool

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

Примеры

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

julia> istril(a)
false

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

julia> istril(b)
true

Base.LinAlg.istriuФункция

istriu(A) -> Bool

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

Примеры

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

julia> istriu(a)
false

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

julia> istriu(b)
true

Base.LinAlg.isdiagФункция

isdiag(A) -> Bool

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

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

Base.LinAlg.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.LinAlg.RowVectorТип

RowVector(vector)

Обёртка ленивой визуализации массива AbstractVector, которая преобразует вектор длины n в вектор-строку размера 1×n и представляет транспонированный вектор (элементы также транспонируются рекурсивно). Этот тип обычно создаётся (и распаковывается) с помощью функции transpose или оператора .' (или связанных операторов ctranspose или ').

По соглашению, вектор может умножаться на матрицу слева (A * v), а вектор-строка — на матрицу справа (так что v.' * A = (A.' * v).'). Он отличается от матрицы размера 1×n тем, что его транспонирование возвращает вектор, а скалярное произведение v1.' * v2 возвращает скаляр, но в остальном ведет себя аналогично.

Base.LinAlg.ConjArrayТип

ConjArray(array)

Обёртка ленивой визуализации массива AbstractArray, берущая комплексно сопряжённое значение каждого элемента. Этот тип обычно создаётся (и распаковывается) с помощью функции conj (или связанных функций ctranspose), но в настоящее время это является стандартным поведением для RowVector только. Для других массивов конструктор ConjArray можно использовать напрямую.

Примеры

julia> [1+im, 1-im]'
1×2 RowVector{Complex{Int64},ConjArray{Complex{Int64},1,Array{Complex{Int64},1}}}:
 1-1im  1+1im

julia> ConjArray([1+im 0; 0 1-im])
2×2 ConjArray{Complex{Int64},2,Array{Complex{Int64},2}}:
 1-1im  0+0im
 0+0im  1+1im

Base.transposeФункция

transpose(A::AbstractMatrix)

Оператор транспонирования (.').

Пример

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> transpose(A)
3×3 Array{Int64,2}:
 1  4  7
 2  5  8
 3  6  9

transpose(v::AbstractVector)

Оператор транспонирования (.').

Пример

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

julia> transpose(v)
1×3 RowVector{Int64,Array{Int64,1}}:
 1  2  3

Base.LinAlg.transpose!Функция

transpose!(dest,src)

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

Base.ctransposeФункция

ctranspose(A)

Оператор сопряжённого транспонирования (').

Пример

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> ctranspose(A)
2×2 Array{Complex{Int64},2}:
 3-2im  8-7im
 9-2im  4-6im

Base.LinAlg.ctranspose!Функция

ctranspose!(dest,src)

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

Base.LinAlg.eigsМетод

eigs(A; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)

Вычисляет собственные значения d матрицы A с использованием неявного перезапуска Ланцоша или Арнольди для симметричных и несимметричных матриц соответственно.

Поддерживаются следующие ключевые аргументы:

• nev: Количество собственных значений

• ncv: Число векторов Крьлова, используемых в вычислениях; должно удовлетворять условиям nev+1 <= ncv <= n для вещественно симметричных задач и nev+2 <= ncv <= n для других задач, где n — размер входной матрицы A. По умолчанию используется ncv = max(20,2*nev+1). Обратите внимание, что эти ограничения ограничивают размер входной матрицы A как минимум до 2.

• which: тип вычисляемых собственных значений. См. примечание ниже.

• tol: параметр, определяющий относительную толерантность для сходимости значений Ритца (оценок собственных значений). Значение Ритца $θ$ считается сошедшимся, когда связанное остаточное значение меньше или равно произведению tol и $max(ɛ^{2/3}, |θ|)$, где ɛ = eps(real(eltype(A)))/2 — машинная эпсилон LAPACK. Остаточное значение, связанное с $θ$ и соответствующим вектором Ритца $v$, определяется нормой $||Av - vθ||$. Указанное значение tol должно быть положительным; в противном случае оно игнорируется, и используется $ɛ$. По умолчанию: $ɛ$.

• maxiter: Максимальное количество итераций (по умолчанию = 300)

• sigma: Указывает сдвиг уровня, используемый в обратной итерации. Если nothing (по умолчанию), используется обычная (прямая) итерация. В противном случае находятся собственные значения, близкие к sigma, с использованием сдвига и обратной итерации.

• ritzvec: Возвращает векторы Ритца v (собственные векторы), если true

• v0: начальный вектор, с которого следует начать итерации

eigs возвращает запрашиваемые nev собственные значения в d, соответствующие векторы Ritz v (только если ritzvec=true), количество сошедшихся собственных значений nconv, количество итераций niter и количество умножений матрицы на вектор nmult, а также конечный вектор остатка resid.

Пример

julia> A = spdiagm(1:4);

julia> λ, ϕ = eigs(A, nev = 2);

julia> λ
2-element Array{Float64,1}:
 4.0
 3.0

Base.LinAlg.eigsМетод

eigs(A, B; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)

Вычисляет обобщенные собственные значения d A и B с использованием неявного перезапуска итераций Ланцоша или Арнольди для вещественных симметричных или общих несимметричных матриц соответственно.

Поддерживаются следующие ключевые аргументы:

• nev: Количество собственных значений

• ncv: Количество векторов Кристова, используемых в вычислениях; должно удовлетворять условиям nev+1 <= ncv <= n для вещественных симметричных задач и nev+2 <= ncv <= n для других задач, где n — размер входных матриц A и B. Значение по умолчанию — ncv = max(20,2*nev+1). Обратите внимание, что эти ограничения ограничивают размер входной матрицы A до размера не менее 2.

• which: тип вычисляемых собственных значений. См. примечание ниже.

• tol: относительная погрешность, используемая в критерии сходимости для собственных значений, аналогично tol в методе eigs(A) для обычной задачи собственных значений, но фактически для собственных значений $B^{-1} A$ вместо $A$. См. документацию по задаче обычных собственных значений в eigs(A) и примечание об tol.

• maxiter: Максимальное число итераций (по умолчанию = 300)

• sigma: Указывает сдвиг уровня, используемый в обратной итерации. Если nothing (по умолчанию), используется обычная (прямая) итерация. В противном случае ищут собственные значения, близкие к sigma с помощью итерации со сдвигом и обращением.

• ritzvec: Возвращает векторы Ritz v (собственные векторы), если true

• v0: начальный вектор, с которого начинаются итерации

eigs возвращает запрашиваемые nev собственные значения в d, соответствующие векторы Ritz v (только если ritzvec=true), количество сошедшихся собственных значений nconv, количество итераций niter и количество умножений матрицы на вектор nmult, а также конечный вектор остатка resid.

Пример

julia> A = speye(4, 4); B = spdiagm(1:4);

julia> λ, ϕ = eigs(A, B, nev = 2);

julia> λ
2-element Array{Float64,1}:
 1.0
 0.5

Base.LinAlg.svdsФункция

svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000, ncv=2*nsv, u0=zeros((0,)), v0=zeros((0,))) -> (SVD([left_sv,] s, [right_sv,]), nconv, niter, nmult, resid)

Вычисляет наибольшие сингулярные значения s A с помощью неявного перезапуска итераций Ланцоша, полученных из eigs.

Входные данные

• A: Линейный оператор, чьи сингулярные значения требуются. A может быть представлен как подтип AbstractArray, например, разреженная матрица, или любой другой тип, поддерживающий четыре метода size(A), eltype(A), A * vector, и A' * vector.

• nsv: Количество сингулярных значений. По умолчанию: 6.

• ritzvec: Если true, возвращает левые и правые сингулярные векторы left_sv и right_sv. Если false, опускает сингулярные векторы. По умолчанию: true.

• tol: точность, см. eigs.

• maxiter: Максимальное число итераций, см. eigs. По умолчанию: 1000.

• ncv: Максимальный размер подпространства Кристова, см. eigs (там называется nev). По умолчанию: 2*nsv.

• u0: Начальное приближение для первого левого вектора Кристова. Он может иметь длину m (первое измерение A) или 0.

• v0: Начальное приближение для первого правого вектора Кристова. Он может иметь длину n (второе измерение A) или 0.

Выходные данные

• svd: Объект SVD, содержащий левые сингулярные векторы, запрошенные значения и правые сингулярные векторы. Если ritzvec = false, левые и правые сингулярные векторы будут пусты.

• nconv: Количество сошедшихся сингулярных значений.

• niter: Количество итераций.

• nmult: Количество матрично-векторных произведений, используемых.

• resid: Конечный вектор остатка.

Пример

julia> A = spdiagm(1:4);

julia> s = svds(A, nsv = 2)[1];

julia> s[:S]
2-element Array{Float64,1}:
 4.0
 3.0

Base.LinAlg.peakflopsФункция

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 по-прежнему относится к размеру задачи, решаемой на каждом процессоре.

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

Операции с матрицами, включающие транспонирование, такие как A' \ B, преобразуются парсером Julia в вызовы специально названных функций, таких как Ac_ldiv_B. Если вы хотите перегрузить эти операции для собственных типов, то полезно знать имена этих функций.

Также во многих случаях существуют "in-place" версии операций с матрицами, которые позволяют вам предоставить предварительно выделенный выходной вектор или матрицу. Это полезно при оптимизации критических участков кода для избежания накладных расходов от повторных выделений. Эти "in-place" операции имеют суффикс ! ниже (например, A_mul_B!) в соответствии с обычной конвенцией Julia.

Base.LinAlg.A_ldiv_B!Функция

A_ldiv_B!([Y,] A, B) -> Y

Вычислить A \ B "in-place" и сохранить результат в Y, вернув результат. Если переданы только два аргумента, то A_ldiv_B!(A, B) перезаписывает B результатом.

Аргумент A не должен быть матрицей. Вместо матриц он должен быть объектом факторизации (например, созданным с помощью factorize или cholfact). Причина в том, что сама факторизация является дорогостоящей и, как правило, выделяет память (хотя ее также можно выполнить "in-place", например, через lufact!), и в критически важных для производительности ситуациях, требующих A_ldiv_B!, обычно также требуется точный контроль над факторизацией A.

Base.A_ldiv_BcФункция

A_ldiv_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A$ \ $Bᴴ$.

Base.A_ldiv_BtФункция

A_ldiv_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A$ \ $Bᵀ$.

Base.LinAlg.A_mul_B!Функция

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

Вычисляет произведение матриц или матрицы и вектора $A⋅B$ и сохраняет результат в 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); A_mul_B!(Y, A, B);

julia> Y
2×2 Array{Float64,2}:
 3.0  3.0
 7.0  7.0

Base.A_mul_BcФункция

A_mul_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A⋅Bᴴ$.

Base.A_mul_BtФункция

A_mul_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A⋅Bᵀ$.

Base.A_rdiv_BcФункция

A_rdiv_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A / Bᴴ$.

Base.A_rdiv_BtФункция

A_rdiv_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $A / Bᵀ$.

Base.Ac_ldiv_BФункция

Ac_ldiv_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ$ \ $B$.

Base.LinAlg.Ac_ldiv_B!Функция

Ac_ldiv_B!([Y,] A, B) -> Y

Аналогично A_ldiv_B!, но возвращает $Aᴴ$ \ $B$, вычисляя результат "in-place" в Y (или перезаписывая B, если Y не указан).

Base.Ac_ldiv_BcФункция

Ac_ldiv_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ$ \ $Bᴴ$.

Base.Ac_mul_BФункция

Ac_mul_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ⋅B$.

Base.Ac_mul_BcФункция

Ac_mul_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ Bᴴ$.

Base.Ac_rdiv_BФункция

Ac_rdiv_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ / B$.

Base.Ac_rdiv_BcФункция

Ac_rdiv_Bc(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᴴ / Bᴴ$.

Base.At_ldiv_BФункция

At_ldiv_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ$ \ $B$.

Base.LinAlg.At_ldiv_B!Функция

At_ldiv_B!([Y,] A, B) -> Y

Аналогично A_ldiv_B!, но возвращает $Aᵀ$ \ $B$, вычисляя результат "in-place" в Y (или перезаписывая B, если Y не указан).

Base.At_ldiv_BtФункция

At_ldiv_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ$ \ $Bᵀ$.

Base.At_mul_BФункция

At_mul_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ⋅B$.

Base.At_mul_BtФункция

At_mul_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ⋅Bᵀ$.

Base.At_rdiv_BФункция

At_rdiv_B(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ / B$.

Base.At_rdiv_BtФункция

At_rdiv_Bt(A, B)

Для матриц или векторов $A$ и $B$ вычисляет $Aᵀ / Bᵀ$.

Функции BLAS

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

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

Аргументы символьного типа BLAS

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

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

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

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

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

Base.LinAlg.BLAS.dotuФункция

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

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

Пример:

julia> Base.BLAS.dotu(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
-10.0 + 10.0im

Base.LinAlg.BLAS.dotcФункция

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

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

Пример:

julia> Base.BLAS.dotc(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
10.0 - 10.0im

Base.LinAlg.BLAS.blascopy!Функция

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

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

Base.LinAlg.BLAS.nrm2Функция

nrm2(n, X, incx)

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

Пример:

julia> Base.BLAS.nrm2(4, ones(8), 2)
2.0

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

Base.LinAlg.BLAS.asumФункция

asum(n, X, incx)

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

Пример:

julia> Base.BLAS.asum(5, im*ones(10), 2)
5.0

julia> Base.BLAS.asum(2, im*ones(10), 5)
2.0

Base.LinAlg.axpy!Функция

axpy!(a, X, Y)

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

Пример:

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

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

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

Base.LinAlg.BLAS.scal!Функция

scal!(n, a, X, incx)

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

Base.LinAlg.BLAS.scalФункция

scal(n, a, X, incx)

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

Base.LinAlg.BLAS.ger!Функция

ger!(alpha, x, y, A)

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

Base.LinAlg.BLAS.syr!Функция

syr!(uplo, alpha, x, A)

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

Base.LinAlg.BLAS.syrk!Функция

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

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

Base.LinAlg.BLAS.syrkФункция

syrk(uplo, trans, alpha, A)

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

Base.LinAlg.BLAS.her!Функция

her!(uplo, alpha, x, A)

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

Base.LinAlg.BLAS.herk!Функция

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

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

Base.LinAlg.BLAS.herkФункция

herk(uplo, trans, alpha, A)

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

Base.LinAlg.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.

Base.LinAlg.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 — скаляр.

Base.LinAlg.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.

Base.LinAlg.BLAS.sbmvМетод

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

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

Base.LinAlg.BLAS.sbmvМетод

sbmv(uplo, k, A, x)

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

Base.LinAlg.BLAS.gemm!Функция

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

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

Base.LinAlg.BLAS.gemmМетод

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

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

Base.LinAlg.BLAS.gemmМетод

gemm(tA, tB, A, B)

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

Base.LinAlg.BLAS.gemv!Функция

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

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

Base.LinAlg.BLAS.gemvМетод

gemv(tA, alpha, A, x)

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

Base.LinAlg.BLAS.gemvМетод

gemv(tA, A, x)

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

Base.LinAlg.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.

Base.LinAlg.BLAS.symmМетод

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

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

Base.LinAlg.BLAS.symmМетод

symm(side, ul, A, B)

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

Base.LinAlg.BLAS.symv!Функция

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

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

Base.LinAlg.BLAS.symvМетод

symv(ul, alpha, A, x)

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

Base.LinAlg.BLAS.symvМетод

symv(ul, A, x)

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

Base.LinAlg.BLAS.trmm!Функция

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

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

Base.LinAlg.BLAS.trmmФункция

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

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

Base.LinAlg.BLAS.trsm!Функция

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

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

Base.LinAlg.BLAS.trsmФункция

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

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

Base.LinAlg.BLAS.trmv!Функция

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

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

Base.LinAlg.BLAS.trmvФункция

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

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

Base.LinAlg.BLAS.trsv!Функция

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

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

Base.LinAlg.BLAS.trsvФункция

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

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

Base.LinAlg.BLAS.set_num_threadsФункция

set_num_threads(n)

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

Base.LinAlg.IКонстанта

I

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

Пример

julia> ones(5, 6) * I == ones(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

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

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

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

Base.LinAlg.LAPACK.gbtrf!Функция

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

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

Base.LinAlg.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 на месте.

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

Base.LinAlg.LAPACK.gebak!Функция

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

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

Base.LinAlg.LAPACK.gebrd!Функция

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

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

Base.LinAlg.LAPACK.gelqf!Функция

gelqf!(A, tau)

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

Возвращает A и tau в измененном виде.

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

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

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

Base.LinAlg.LAPACK.geqlf!Функция

geqlf!(A, tau)

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

Возвращает A и tau в измененном виде.

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

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

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

Base.LinAlg.LAPACK.geqrf!Функция

geqrf!(A, tau)

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

Возвращает A и tau в измененном виде.

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

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

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

Base.LinAlg.LAPACK.geqp3!Функция

geqp3!(A, jpvt, tau)

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

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

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

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

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

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

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

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

Base.LinAlg.LAPACK.gerqf!Функция

gerqf!(A, tau)

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

Возвращает A и tau в измененном виде.

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

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

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

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

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

Base.LinAlg.LAPACK.getrf!Функция

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

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

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

Base.LinAlg.LAPACK.tzrzf!Функция

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

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

Base.LinAlg.LAPACK.ormrz!Функция

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

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

Base.LinAlg.LAPACK.gels!Функция

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

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

Base.LinAlg.LAPACK.gesv!Функция

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

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

Base.LinAlg.LAPACK.getrs!Функция

getrs!(trans, A, ipiv, B)

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

Base.LinAlg.LAPACK.getri!Функция

getri!(A, ipiv)

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

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

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

gesvx!(A, B)

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

Base.LinAlg.LAPACK.gelsd!Функция

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

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

Base.LinAlg.LAPACK.gelsy!Функция

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

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

Base.LinAlg.LAPACK.gglse!Функция

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

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

Base.LinAlg.LAPACK.geev!Функция

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

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

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

Base.LinAlg.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.

Base.LinAlg.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.

Base.LinAlg.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.

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

Base.LinAlg.LAPACK.ggev!Функция

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

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

Base.LinAlg.LAPACK.gtsv!Функция

gtsv!(dl, d, du, B)

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

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

Base.LinAlg.LAPACK.gttrf!Функция

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

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

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

Base.LinAlg.LAPACK.gttrs!Функция

gttrs!(trans, dl, d, du, du2, ipiv, B)

Решает уравнение A * X = B (trans = N), A.' * X = B (trans = T) или A' * X = B (trans = C) используя факторизацию LU, вычисленную gttrf!. B перезаписывается решением X.

Base.LinAlg.LAPACK.orglq!Функция

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

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

Base.LinAlg.LAPACK.orgqr!Функция

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

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

Base.LinAlg.LAPACK.orgql!Функция

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

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

Base.LinAlg.LAPACK.orgrq!Функция

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

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

Base.LinAlg.LAPACK.ormlq!Функция

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

Вычисляет Q * C (trans = N), Q.' * C (trans = T), Q' * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из LQ факторизации A, вычисленной с помощью gelqf!. C перезаписывается.

Base.LinAlg.LAPACK.ormqr!Функция

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

Вычисляет Q * C (trans = N), Q.' * C (trans = T), Q' * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из QR факторизации A, вычисленной с помощью geqrf!. C перезаписывается.

Base.LinAlg.LAPACK.ormql!Функция

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

Вычисляет Q * C (trans = N), Q.' * C (trans = T), Q' * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из QL факторизации A, вычисленной с помощью geqlf!. C перезаписывается.

Base.LinAlg.LAPACK.ormrq!Функция

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

Вычисляет Q * C (trans = N), Q.' * C (trans = T), Q' * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из RQ факторизации A, вычисленной с помощью gerqf!. C перезаписывается.

Base.LinAlg.LAPACK.gemqrt!Функция

gemqrt!(side, trans, V, T, C)

Вычисляет Q * C (trans = N), Q.' * C (trans = T), Q' * C (trans = C) для side = L или эквивалентное правое умножение для side = R с использованием Q из QR факторизации A, вычисленной с помощью geqrt!. C перезаписывается.

Base.LinAlg.LAPACK.posv!Функция

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

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

Base.LinAlg.LAPACK.potrf!Функция

potrf!(uplo, A)

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

Base.LinAlg.LAPACK.potri!Функция

potri!(uplo, A)

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

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

Base.LinAlg.LAPACK.potrs!Функция

potrs!(uplo, A, B)

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

Base.LinAlg.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 является неопределённой или имеет недостаточный ранг.

Base.LinAlg.LAPACK.ptsv!Функция

ptsv!(D, E, B)

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

Base.LinAlg.LAPACK.pttrf!Функция

pttrf!(D, E)

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

Base.LinAlg.LAPACK.pttrs!Функция

pttrs!(D, E, B)

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

Base.LinAlg.LAPACK.trtri!Функция

trtri!(uplo, diag, A)

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

Base.LinAlg.LAPACK.trtrs!Функция

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

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

Base.LinAlg.LAPACK.trcon!Функция

trcon!(norm, uplo, diag, A)

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

Base.LinAlg.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.

Base.LinAlg.LAPACK.trrfs!Функция

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

Оценивает ошибку в решении для A * X = B (trans = N), A.' * X = B (trans = T), 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 — ошибка назад, каждый компонентно.

Base.LinAlg.LAPACK.stev!Функция

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

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

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

Base.LinAlg.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.

Base.LinAlg.LAPACK.stein!Функция

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

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

Base.LinAlg.LAPACK.syconv!Функция

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

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

Base.LinAlg.LAPACK.sysv!Функция

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

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

Base.LinAlg.LAPACK.sytrf!Функция

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

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

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

Base.LinAlg.LAPACK.sytri!Функция

sytri!(uplo, A, ipiv)

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

Base.LinAlg.LAPACK.sytrs!Функция

sytrs!(uplo, A, ipiv, B)

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

Base.LinAlg.LAPACK.hesv!Функция

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

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

Base.LinAlg.LAPACK.hetrf!Функция

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

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

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

Base.LinAlg.LAPACK.hetri!Функция

hetri!(uplo, A, ipiv)

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

Base.LinAlg.LAPACK.hetrs!Функция

hetrs!(uplo, A, ipiv, B)

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

Base.LinAlg.LAPACK.syev!Функция

syev!(jobz, uplo, A)

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

Base.LinAlg.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.

Base.LinAlg.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.

Base.LinAlg.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.

Base.LinAlg.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.

Base.LinAlg.LAPACK.gecon!Функция

gecon!(normtype, A, anorm)

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

Base.LinAlg.LAPACK.gehrd!Функция

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

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

Base.LinAlg.LAPACK.orghr!Функция

orghr!(ilo, ihi, A, tau)

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

Base.LinAlg.LAPACK.gees!Функция

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

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

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

Base.LinAlg.LAPACK.gges!Функция

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

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

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

Base.LinAlg.LAPACK.trexc!Функция

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

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

Base.LinAlg.LAPACK.trsen!Функция

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

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

Возвращает T, Q, и упорядоченные по возрастанию собственные значения в w.

Base.LinAlg.LAPACK.tgsen!Функция

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

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

Base.LinAlg.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.