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

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

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

*(A, B): Умножение матриц.

\(A, B)

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

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

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

dot(x, y)
⋅(x, y): Вычислить скалярное произведение. Для комплексных векторов первый вектор сопрягается.

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

cross(x, y)
×(x, y): Вычислить векторное произведение двух 3-векторов.

factorize(A)

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

Свойства `A`	Тип факторизации
Положительно определенная	Холецкого (см. `cholfact()`)
Плотный симметричный/эрмитов	Банч-Коуфмана (см. `bkfact()`)
Разреженный симметричный/эрмитов	LDLt (см. `ldltfact()`)
Треугольная	Треугольная
Диагональная	Диагональная
Бидиагональная	Бидиагональная
Трехдиагональная	LU (см. `lufact()`)
Симметричная реальная трехдиагональная	LDLt (см. `ldltfact()`)
Общая квадратная	LU (см. `lufact()`)
Общая неквадратная	QR (см. `qrfact()`)

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

Пример:

A = diagm(rand(5)) + diagm(rand(4),1); #A is really bidiagonal
factorize(A) #factorize will check to see that A is already factorized

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

full(F): Восстановить матрицу A из факторизации F=factorize(A).

Diagonal(A::AbstractMatrix): Создает матрицу из диагонали A.

Diagonal(V::AbstractVector): Создает матрицу с V в качестве диагонали.

Bidiagonal(dv, ev, isupper::Bool)

Создает верхнюю (isupper=true) или нижнюю (isupper=false) бидиагональную матрицу, используя заданные диагональные (dv) и внедиагональные (ev) векторы. Результат имеет тип Bidiagonal и обеспечивает эффективные специализированные линейные решатели, но может быть преобразован в обычную матрицу с помощью full(). Длина ev должна быть на единицу меньше длины dv.

Пример

dv = rand(5)
ev = rand(4)
Bu = Bidiagonal(dv, ev, true) #e is on the first superdiagonal
Bl = Bidiagonal(dv, ev, false) #e is on the first subdiagonal

Bidiagonal(dv, ev, uplo::Char)

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

Пример

dv = rand(5)
ev = rand(4)
Bu = Bidiagonal(dv, ev, 'U') #e is on the first superdiagonal
Bl = Bidiagonal(dv, ev, 'L') #e is on the first subdiagonal

Bidiagonal(A, isupper::Bool)

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

Пример

A = rand(5,5)
Bu = Bidiagonal(A, true) #contains the main diagonal and first superdiagonal of A
Bl = Bidiagonal(A, false) #contains the main diagonal and first subdiagonal of A

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

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

Symmetric(A, uplo=:U)

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

Пример

A = randn(10,10)
Supper = Symmetric(A)
Slower = Symmetric(A,:L)
eigfact(Supper)

eigfact будет использовать метод, специализированный для матриц, известные как симметричные. Обратите внимание, что Supper не будет равно Slower, если A сама не симметрична (например, если A == A.').

Hermitian(A, uplo=:U)

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

Пример

A = randn(10,10)
Hupper = Hermitian(A)
Hlower = Hermitian(A,:L)
eigfact(Hupper)

eigfact будет использовать метод, специализированный для матриц, известные как эрмитовы. Обратите внимание, что Hupper не будет равно Hlower, если A сама не эрмитова (например, если A == A').

lu(A) → L, U, p: Вычислить LU-факторизацию A, так что A[p,:] = L*U.

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

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

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

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

Компонент	Описание
`F[:L]`	`L` (нижняя треугольная) часть `LU`
`F[:U]`	`U` (верхняя треугольная) часть `LU`
`F[:p]`	(правая) перестановка `Vector`
`F[:P]`	(правая) перестановка `Matrix`

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

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

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

Поддерживаемая функция	`LU`	`LU{T,Tridiagonal{T}}`
`/()`	✓
`\()`	✓	✓
`cond()`	✓
`det()`	✓	✓
`logdet()`	✓	✓
`logabsdet()`	✓	✓
`size()`	✓	✓

lufact(A::SparseMatrixCSC) → F::UmfpackLU

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

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

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

Компонент	Описание
`F[:L]`	`L` (нижняя треугольная) часть `LU`
`F[:U]`	`U` (верхняя треугольная) часть `LU`
`F[:p]`	правая перестановка `Vector`
`F[:q]`	левая перестановка `Vector`
`F[:Rs]`	`Vector` множителей масштабирования
`F[:(:)]`	`(L,U,p,q,Rs)` компоненты

Связь между F и A:

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

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

\()
cond()
det()

** Примечание по реализации **

lufact(A::SparseMatrixCSC) использует библиотеку UMFPACK, которая входит в SuiteSparse. Поскольку эта библиотека поддерживает только разреженные матрицы с Float64 или Complex128 элементами, lufact преобразует A в копию типа SparseMatrixCSC{Float64} или SparseMatrixCSC{Complex128} соответственно.

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

chol(A) → U: Вычислить разложение Холецкого положительно определенной матрицы A и вернуть верхнетреугольную матрицу U такую, что A = U'U.

chol(x::Number) → y: Вычислить квадратный корень неотрицательного числа x.

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

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 определяет пороговое значение для определения ранга. Для отрицательных значений порог равен машинной точности.

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

Вычислить разложение Холецкого разреженной положительно определенной матрицы A. A должна быть SparseMatrixCSC, Symmetric{SparseMatrixCSC}, или 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).

Примечание

Этот метод использует библиотеку CHOLMOD из SuiteSparse, которая поддерживает только типы данных double или complex double. Входные матрицы, не имеющие этих типов элементов, будут преобразованы в SparseMatrixCSC{Float64} или SparseMatrixCSC{Complex128} соответственно.

Многие другие функции из CHOLMOD обернуты, но не экспортированы из модуля Base.SparseArrays.CHOLMOD.

cholfact!(F::Factor, A; shift = 0.0) → CHOLMOD.Factor: Вычислить разложение Холецкого (\(LL'\)) A, повторно используя символическую факторизацию F. A должна быть SparseMatrixCSC, Symmetric{SparseMatrixCSC}, или Hermitian{SparseMatrixCSC}. Обратите внимание, что даже если A не имеет метки типа, она должна быть симметричной или эрмитовой.

Примечание

Этот метод использует библиотеку CHOLMOD из SuiteSparse, которая поддерживает только типы данных double или complex double. Входные матрицы, не имеющие этих типов элементов, будут преобразованы в SparseMatrixCSC{Float64} или SparseMatrixCSC{Complex128} соответственно.

cholfact!(A, [uplo::Symbol, ]Val{false}) → Cholesky: То же самое, что и cholfact, но экономит место, перезаписывая входной A, вместо создания копии. Исключение InexactError выбрасывается, если факторизация даёт число, не представимое типом элементов A, например, для целочисленных типов.

cholfact!(A, [uplo::Symbol, ]Val{true}; tol = 0.0) → CholeskyPivoted: То же самое, что и cholfact, но экономит место, перезаписывая входной A, вместо создания копии. Исключение InexactError выбрасывается, если факторизация даёт число, не представимое типом элементов A, например, для целочисленных типов.

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) операций.

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) операций.

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 уничтожается во время вычислений.

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 уничтожается во время вычислений.

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

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

Вычислить факторизацию \(LDL'\) разреженной матрицы A. A должна быть SparseMatrixCSC, Symmetric{SparseMatrixCSC}, или Hermitian{SparseMatrixCSC}. Обратите внимание, что даже если у A нет метки типа, она всё равно должна быть симметричной или эрмитовой. Используется заполнение, уменьшающее перестановку. F = ldltfact(A) чаще всего используется для решения систем уравнений A*x = b с F\b. Возвращаемый объект факторизации F также поддерживает методы diag, det, и logdet. Вы можете извлечь отдельные факторы из 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) , задающей порядок (вместо по умолчанию AMD-упорядочивания CHOLMOD).

Примечание

Этот метод использует библиотеку CHOLMOD из SuiteSparse, которая поддерживает только числа с плавающей точкой двойной точности или комплексные числа двойной точности. Матрицы входных данных, не являющиеся такими типами элементов, будут преобразованы в SparseMatrixCSC{Float64} или SparseMatrixCSC{Complex128} соответственно.

Многие другие функции из CHOLMOD обернуты, но не экспортированы из модуля Base.SparseArrays.CHOLMOD.

ldltfact!(F::Factor, A; shift = 0.0) → CHOLMOD.Factor: Вычислить факторизацию \(LDL'\) для A, повторно используя символическую факторизацию F. A должна быть SparseMatrixCSC, Symmetric{SparseMatrixCSC}, или Hermitian{SparseMatrixCSC}. Обратите внимание, что даже если у A нет метки типа, она всё равно должна быть симметричной или эрмитовой.

Примечание

Этот метод использует библиотеку CHOLMOD из SuiteSparse, которая поддерживает только числа с плавающей точкой двойной точности или комплексные числа двойной точности. Матрицы входных данных, не являющиеся такими типами элементов, будут преобразованы в SparseMatrixCSC{Float64} или SparseMatrixCSC{Complex128} соответственно.

ldltfact!(::SymTridiagonal) → LDLt: То же самое, что и ldltfact, но экономит место, перезаписывая входной A, вместо создания копии.

qr(v::AbstractVector)

Вычисляет полярное разложение вектора.

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

v::AbstractVector - вектор для нормализации

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

w - единичный вектор в направлении v
r - норма v

См. также:

normalize, normalize!, LinAlg.qr!

LinAlg.qr!(v::AbstractVector)

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

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

v::AbstractVector - вектор для нормализации

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

w - единичный вектор в направлении v (это изменение v).
r - норма v

См. также:

normalize, normalize!, qr

qr(A[, pivot=Val{false}][;thin=true]) → Q, R, [p]: Вычислить (с перестановкой) QR-факторизацию A таким образом, чтобы иметь либо A = Q*R, либо A[:,p] = Q*R. Также см. qrfact. По умолчанию вычисляется тонкая факторизация. Обратите внимание, что R не расширяется нулями, когда требуется полная Q.

qrfact(A[, pivot=Val{false}]) → F

Вычисляет QR-разложение A. Тип возвращаемого значения F зависит от типа элементов A и от того, указано ли применение поворота (с помощью pivot==Val{true}).

Тип возвращаемого значения	`eltype(A)`	`pivot`	Взаимосвязь между `F` и `A`
`QR`	не `BlasFloat`	любой	`A==F[:Q]*F[:R]`
`QRCompactWY`	`BlasFloat`	`Val{false}`	`A==F[:Q]*F[:R]`
`QRPivoted`	`BlasFloat`	`Val{true}`	`A[:,F[:p]]==F[:Q]*F[:R]`

BlasFloat относится к любому из типов: Float32, Float64, Complex64 или Complex128.

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

Компонент	Описание	`QR`	`QRCompactWY`	`QRPivoted`
`F[:Q]`	`Q` (ортогональная/унитарная) часть `QR`	✓ (`QRPackedQ`)	✓ (`QRCompactWYQ`)	✓ (`QRPackedQ`)
`F[:R]`	`R` (верхняя правая треугольная) часть `QR`	✓	✓	✓
`F[:p]`	опорный `Vector`			✓
`F[:P]`	(опорная) перестановка `Matrix`			✓

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

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

Примечание

qrfact возвращает несколько типов, потому что LAPACK использует несколько представлений, которые минимизируют требования к памяти для произведений элементарных отражателей Хаусхолдера, так что матрицы Q и R могут храниться компактно, а не как две отдельные плотные матрицы.

Данные, содержащиеся в QR или QRPivoted , могут быть использованы для построения типа QRPackedQ, который является компактным представлением матрицы вращения:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T)\]

где \(\tau_i\) — масштабный множитель, а \(v_i\) — вектор проекции, связанный с \(i^{th}\) элементарным отражателем Хаусхолдера.

Данные, содержащиеся в QRCompactWY , могут быть использованы для построения типа QRCompactWYQ, который является компактным представлением матрицы вращения

\[Q = I + Y T Y^T\]

где Y является нижней трапециевидной \(m \times r\) , а T является верхней треугольной \(r \times r\). Представление компактного WY [Schreiber1989] не следует путать со старым представлением WY [Bischof1987]. (Документация LAPACK использует V вместо Y.)

[Bischof1987]

(1, 2) C Bischof and C Van Loan, “The WY representation for products of Householder matrices”, SIAM J Sci Stat Comput 8 (1987), s2-s13. doi:10.1137/0908009

[Schreiber1989]

R Schreiber and C Van Loan, “A storage-efficient WY representation for products of Householder transformations”, SIAM J Sci Stat Comput 10 (1989), 53-57. doi:10.1137/0910005

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

qrfact!(A[, pivot=Val{false}]): qrfact! аналогичен qrfact(), когда A является подтипом StridedMatrix, но экономит место, перезаписывая входные данные A, вместо создания копии. Исключение InexactError генерируется, если факторизация приводит к числу, не представимому типом элементов A, например, для целочисленных типов.

full(QRCompactWYQ[, thin=true]) → Matrix

Преобразует ортогональную или унитарную матрицу, хранящуюся как объект QRCompactWYQ, т.е. в компактном формате WY [Bischof1987], в плотную матрицу.

По желанию принимает булевый аргумент thin, который, если true опускает столбцы, описывающие нулевые строки R в QR-разложении. Результирующая матрица — Q в тонком QR-разложении (иногда называемом сокращённым QR-разложением). Если false, возвращает Q , охватывающий все строки R в соответствующем QR-разложении.

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

lqfact(A) → LQ: Вычисляет LQ-разложение A. См. также lq().

lq(A; [thin=true]) → L, Q: Выполняет LQ-разложение A таким образом, что A = L*Q. По умолчанию вычисляется тонкое разложение. LQ-разложение — это QR-разложение A.'. L не дополняется нулями, если требуется полное Q.

bkfact(A) → BunchKaufman

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

[Bunch1977]

J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. url.

bkfact!(A) → BunchKaufman: bkfact! аналогично bkfact(), но экономит место, перезаписывая входные данные A, вместо создания копии.

eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) → D, V

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

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.

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])

eigvals(A,[irange,][vl,][vu]) → values

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

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

eigvals!(A,[irange,][vl,][vu]) → values: То же, что и eigvals(), но экономит место, перезаписывая входные данные A, вместо создания копии.

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:
 in #eigmax#30(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:186
 in eigmax(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:184
 ...

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:
 in #eigmin#31(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:226
 in eigmin(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:224
 ...

eigvecs(A, [eigvals,][permute=true,][scale=true]) → Matrix

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

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

eigfact(A,[irange,][vl,][vu,][permute=true,][scale=true]) → Eigen

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

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

Если A является Symmetric, Hermitian или SymTridiagonal, можно вычислить только подмножество собственных значений, указав либо UnitRange irange , охватывающий индексы отсортированных собственных значений, либо пару vl и vu для нижней и верхней границ собственных значений.

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

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

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

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

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

schurfact!(A::StridedMatrix) → F::Schur: Аналогично schurfact, но использует входной аргумент в качестве рабочей области.

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

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

См. schurfact.

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

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

ordschur!(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool}, BitVector}) → T::StridedMatrix, Z::StridedMatrix, λ::Vector: Аналогично ordschur, но перезаписывает входные аргументы.

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

schurfact!(A::StridedMatrix, B::StridedMatrix) → F::GeneralizedSchur: Аналогично schurfact, но использует входные матрицы A и B в качестве рабочей области.

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

ordschur!(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) → S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector: То же самое, что и ordschur, но перезаписывает факторизацию входных аргументов.

schur(A::StridedMatrix, B::StridedMatrix) → S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector: См. schurfact.

svdfact(A[, thin=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.

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

svdfact!(A[, thin=true]) → SVD

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

svd(A[, thin=true]) → U, S, V

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

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

svdvals(A): Возвращает сингулярные значения A.

svdvals!(A): Возвращает сингулярные значения A, экономя память путём перезаписи входных данных.

svdfact(A, B) → GeneralizedSVD

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

Для матрицы M-на-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 и более поздних версиях).

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

svdvals(A, B): Возвращает обобщённые сингулярные значения из обобщённого сингулярного разложения A и B.

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

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(x::AbstractVector, i1::Integer, i2::Integer) → (G::Givens, r)

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

B = G*x

имеет свойство

B[i1] = r
B[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

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

triu(M, k): Возвращает верхнюю треугольную часть M начиная с k-й наддиагонали.

triu!(M): Верхняя треугольная часть матрицы, перезаписывая M в процессе.

triu!(M, k): Возвращает верхнюю треугольную часть M начиная с k-й наддиагонали, перезаписывая M в процессе.

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

tril(M, k): Возвращает нижнюю треугольную часть M начиная с k-й наддиагонали.

tril!(M): Нижняя треугольная часть матрицы, перезаписывая M в процессе.

tril!(M, k): Возвращает нижнюю треугольную часть M начиная с k-й наддиагонали, перезаписывая M в процессе.

diagind(M[, k]): Массив, содержащий индексы Range-й диагонали матрицы M.

diag(M[, k]): k-я диагональ матрицы в виде вектора. Используйте diagm для построения диагональной матрицы.

diagm(v[, k]): Построение диагональной матрицы и размещение v на k-й диагонали.

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.

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

rank(M): Вычислить ранг матрицы.

norm(A[, p])

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

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

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

vecnorm(A[, p])

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

Например, если A является матрицей и p=2, то это эквивалентно норме Фробениуса.

normalize!(v[, p=2])

Нормализовать вектор v на месте относительно p-нормы.

Входы:

v::AbstractVector - вектор, подлежащий нормализации
p::Real - p-норма, относительно которой нормализовать. По умолчанию: 2

Выход:

v - единичный вектор, представляющий входной вектор, масштабированный для получения нормы 1. Входной вектор изменяется на месте.

См. также:

normalize, qr

normalize(v[, p=2])

Нормализовать вектор v относительно p-нормы.

Входы:

v::AbstractVector - вектор, подлежащий нормализации
p::Real - p-норма, относительно которой нормализовать. По умолчанию: 2

Выход:

v - единичный вектор, являющийся копией входного вектора, масштабированного для получения нормы 1

См. также:

normalize!, qr

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

condskeel(M[, x, p])

\[\begin{split}\kappa_S(M, p) & = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) & = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p\end{split}\]

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

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

trace(M): След матрицы.

det(M): Определитель матрицы.

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

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

inv(M): Обратная матрица.

pinv(M[, tol])

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

Для матриц 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].

[issue8859]

Задача 8859, «Исправить метод наименьших квадратов», https://github.com/JuliaLang/julia/pull/8859

[B96]

Åke Björck, «Численные методы для задач наименьших квадратов», SIAM Press, Филадельфия, 1996, «Другие названия в прикладной математике», т. 51. doi:10.1137/1.9781611971484

[S84]

1. Stewart, «Вырожденность ранга», SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. doi:10.1137/0905030

[KY88]

Константинос Константинидес и Кунг Яо, «Статистический анализ эффективных сингулярных значений при определении ранга матрицы», IEEE Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988, 757-763. doi:10.1109/29.1585

nullspace(M): Базис для нуль-пространства M.

repmat(A, n, m): Построить матрицу, повторяя данную матрицу n раз по размерности 1 и m раз по размерности 2.

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

kron(A, B): Кронекеровское тензорное произведение двух векторов или двух матриц.

blkdiag(A...): Объединить матрицы по блочно-диагональной схеме. В настоящее время реализовано только для разреженных матриц.

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

expm(A)

Вычислить матричную экспоненту A, определяемую

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

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

[H05]

Nicholas J. Higham, “The squaring and scaling method for the matrix exponential revisited”, SIAM Journal on Matrix Analysis and Applications, 26(4), 2005, 1179-1193. doi:10.1137/090768539

logm(A::StridedMatrix)

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

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

[AH12]

Awad H. Al-Mohy and Nicholas J. Higham, “Improved inverse scaling and squaring algorithms for the matrix logarithm”, SIAM Journal on Scientific Computing, 34(4), 2012, C153-C169. doi:10.1137/110852553

[AHR13]

Awad H. Al-Mohy, Nicholas J. Higham and Samuel D. Relton, “Computing the Fréchet derivative of the matrix logarithm and estimating the condition number”, SIAM Journal on Scientific Computing, 35(4), 2013, C394-C410. doi:10.1137/120885991

sqrtm(A)

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

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

[BH83]

Åke Björck and Sven Hammarling, “A Schur method for the square root of a matrix”, Linear Algebra and its Applications, 52-53, 1983, 127-140. doi:10.1016/0024-3795(83)80010-X

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

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

issymmetric(A) → Bool: Проверка, является ли матрица симметричной.

isposdef(A) → Bool: Проверка, является ли матрица положительно определенной.

isposdef!(A) → Bool: Проверка, является ли матрица положительно определенной, перезаписывая A в процессе.

istril(A) → Bool: Проверка, является ли матрица нижнетреугольной.

istriu(A) → Bool: Проверка, является ли матрица верхнетреугольной.

isdiag(A) → Bool: Проверка, является ли матрица диагональной.

ishermitian(A) → Bool: Проверка, является ли матрица эрмитовой.

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

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

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

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

END_OF_DOCUMENT_MARKER

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: тип вычисляемых собственных значений. См. примечание ниже.

`which`	тип собственных значений
`:LM`	собственные значения наибольшего модуля (по умолчанию)
`:SM`	собственные значения наименьшего модуля
`:LR`	собственные значения с наибольшей действительной частью
`:SR`	собственные значения с наименьшей действительной частью
`:LI`	собственные значения с наибольшей мнимой частью (несимметричная или комплексная `A` только)
`:SI`	собственные значения с наименьшей мнимой частью (несимметричная или комплексная `A` только)
`:BE`	вычислить половину собственных значений с каждого конца спектра, с большей вероятностью выбирая значения с высокой стороны. (только вещественно-симметричная `A` )

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, соответствующие векторы Ритца v (только если ritzvec=true), количество сходящихся собственных значений nconv, количество итераций niter и количество умножений матрицы на вектор nmult, а также конечный вектор остатка resid.

Примечание

Ключевые слова sigma и which взаимодействуют: описание искомых собственных значений which не обязательно относятся к собственным значениям A, а скорее к линейному оператору, построенному по заданному режиму итераций, имплицитному в sigma.

`sigma`	режим итераций	`which` относится к собственным значениям
`nothing`	обычный (прямой)	\(A\)
вещественный или комплексный	обратный со сдвигом уровня `sigma`	\((A - \sigma I )^{-1}\)

Примечание

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

Подробности о том, как оцениваются погрешности вычисленных собственных значений, см. в:

1. 1. Parlett, «The Symmetric Eigenvalue Problem», SIAM: Philadelphia, 2/e (1998), Глава 13.2, «Доступ к точности в задачах Ланцоша», стр. 290-292 и далее.
1. 1. Lehoucq и D. C. Sorensen, «Deflation Techniques for an Implicitly Restarted Arnoldi Iteration», SIAM Journal on Matrix Analysis and Applications (1996), 17(4), 789–821. doi:10.1137/S0895479895281484

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: тип вычисляемых собственных значений. См. примечание ниже.

`which`	тип собственных значений
`:LM`	собственные значения наибольшего модуля (по умолчанию)
`:SM`	собственные значения наименьшего модуля
`:LR`	собственные значения с наибольшей действительной частью
`:SR`	собственные значения с наименьшей действительной частью
`:LI`	собственные значения с наибольшей мнимой частью (несимметричная или комплексная `A` только)
`:SI`	собственные значения с наименьшей мнимой частью (несимметричная или комплексная `A` только)
`:BE`	вычислить половину собственных значений с каждого конца спектра, с большей вероятностью выбирая значения с высокой стороны. (только вещественно-симметричная `A` только)

tol: относительная толерантность, используемая в критерии сходимости для собственных значений, аналогична tol в методе eigs() для обычной задачи на собственные значения, но эффективно для собственных значений \(B^{-1} A\) вместо \(A\). См. документацию для обычной задачи на собственные значения в eigs() и сопутствующее примечание о tol.
maxiter: Максимальное количество итераций (по умолчанию = 300)
sigma: Указывает сдвиг уровня, используемый в обратной итерации. Если nothing (по умолчанию), используется обычная (прямая) итерация. В противном случае, находят собственные значения, близкие к sigma с использованием итераций сдвига и обратного преобразования.
ritzvec: Возвращает векторы Ритца v (собственные векторы), если true
v0: начальный вектор, с которого начинаются итерации

Пример

X = sprand(10, 5, 0.2)
eigs(X, nsv = 2, tol = 1e-3)

Примечание

Ключевые слова sigma и which взаимодействуют: описание искомых собственных значений which не обязательно относится к задаче на собственные значения \(Av = Bv\lambda\), а скорее к линейному оператору, построенному по заданному режиму итераций, имплицитному в sigma.

`sigma`	режим итераций	`which` относится к задаче
`nothing`	обычный (прямой)	\(Av = Bv\lambda\)
вещественный или комплексный	обратный со сдвигом уровня `sigma`	\((A - \sigma B )^{-1}B = v\nu\)

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: Конечный остаточный вектор.

Пример

X = sprand(10, 5, 0.2)
svds(X, nsv = 2)

Примечание по реализации

svds(A) формально эквивалентно вызову eigs для выполнения неявно перезапускаемой тридиагональной итерации Ланцоша для эрмитовой матрицы \(\begin{pmatrix} 0 & A^\prime \\ A & 0 \end{pmatrix}\), собственные значения которой являются плюс и минус сингулярными значениями \(A\).

peakflops(n; parallel=false)

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

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

A_ldiv_B!([Y, ]A, B) → Y

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

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

A_ldiv_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A\) \ \(Bᴴ\).

A_ldiv_Bt(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A\) \ \(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

A_mul_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A⋅Bᴴ\).

A_mul_Bt(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A⋅Bᵀ\).

A_rdiv_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A / Bᴴ\).

A_rdiv_Bt(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(A / Bᵀ\).

Ac_ldiv_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ\) \ \(B\).

Ac_ldiv_B!([Y, ]A, B) → Y: Аналогично A_ldiv_B!(), но возвращает \(Aᴴ\) \ \(B\), вычисляя результат «на месте» в Y (или перезаписывая B если Y не указан).

Ac_ldiv_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ\) \ \(Bᴴ\).

Ac_mul_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ⋅B\).

Ac_mul_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ Bᴴ\).

Ac_rdiv_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ / B\).

Ac_rdiv_Bc(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᴴ / Bᴴ\).

At_ldiv_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᵀ\) \ \(B\).

At_ldiv_B!([Y, ]A, B) → Y: Аналогично A_ldiv_B!(), но возвращает \(Aᵀ\) \ \(B\), вычисляя результат «на месте» в Y (или перезаписывая B если Y не указан).

At_ldiv_Bt(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᵀ\) \ \(Bᵀ\).

At_mul_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᵀ⋅B\).

At_mul_Bt(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᵀ⋅Bᵀ\).

At_rdiv_B(A, B): Для матриц или векторов \(A\) и \(B\) вычисляет \(Aᵀ / B\).

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 массивов.

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

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

dotc(n, X, incx, U, incy): Функция скалярного произведения для двух комплексных векторов, конъюгирующая первый вектор.

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

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

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

axpy!(a, X, Y): Перезаписать Y значением a*X + Y. Возвращает Y.

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

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

ger!(alpha, x, y, A): Обновление матрицы A с векторами x и y как alpha*x*y' + A.

syr!(uplo, alpha, x, A): Обновление симметричной матрицы A с вектором x как alpha*x*x.' + A. Когда uplo равно ‘U’, обновляется верхняя треугольная часть A (‘L’ для нижней треугольной части). Возвращает A.

syrk!(uplo, trans, alpha, A, beta, C): Обновление симметричной матрицы C как alpha*A*A.' + beta*C или alpha*A.'*A + beta*C в зависимости от того, является ли trans ‘N’ или ‘T’. Когда uplo равно ‘U’, обновляется верхняя треугольная часть C (‘L’ для нижней треугольной части). Возвращает C.

syrk(uplo, trans, alpha, A): Возвращает либо верхнюю треугольную часть, либо нижнюю треугольную часть в зависимости от uplo (‘U’ или ‘L’), матрицы alpha*A*A.' или alpha*A.'*A, в зависимости от trans (‘N’ или ‘T’).

her!(uplo, alpha, x, A): Методы только для комплексных массивов. Обновление эрмитовой матрицы A с вектором x как alpha*x*x' + A. Когда uplo равно ‘U’, обновляется верхняя треугольная часть A (‘L’ для нижней треугольной части). Возвращает A.

herk!(uplo, trans, alpha, A, beta, C): Методы только для комплексных массивов. Обновление эрмитовой матрицы C как alpha*A*A' + beta*C или alpha*A'*A + beta*C в зависимости от того, является ли trans ‘N’ или ‘T’. Когда uplo равно ‘U’, обновляется верхняя треугольная часть C (‘L’ для нижней треугольной части). Возвращает C.

herk(uplo, trans, alpha, A): Методы только для комплексных массивов. Возвращает либо верхнюю треугольную часть, либо нижнюю треугольную часть, в зависимости от uplo (‘U’ или ‘L’), матрицы alpha*A*A' или alpha*A'*A, в зависимости от trans (‘N’ или ‘T’).

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

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

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

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

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

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

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

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

gemm(tA, tB, A, B): Возвращает A*B или другие три варианта в зависимости от tA (транспонирование A) и tB.

gemv!(tA, alpha, A, x, beta, y): Обновляет вектор y как alpha*A*x + beta*y или alpha*A'x + beta*y в зависимости от tA (транспонирование A). Возвращает обновлённый y.

gemv(tA, alpha, A, x): Возвращает alpha*A*x или alpha*A'x в зависимости от tA (транспонирование A).

gemv(tA, A, x): Возвращает A*x или A'x в зависимости от tA (транспонирование A).

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

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

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

symm(tA, tB, alpha, A, B): Возвращает alpha*A*B или другие три варианта в соответствии с tA (транспонирование A) и tB.

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

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

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

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

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

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

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

trmv!(ul, tA, dA, A, b): Возвращает op(A)*b, где op определяется tA (N для единичной матрицы, T для транспонирования A, и C для сопряжённого транспонирования A). Используется только ul треугольная часть (U для верхней, L для нижней) A. dA указывает, является ли A унитреугольной (диагональ предполагается равной единице, если U, или не-унитреугольной, если N). Умножение происходит непосредственно в b.

trmv(ul, tA, dA, A, b): Возвращает op(A)*b, где op определяется tA (N для единичной матрицы, T для транспонирования A, и C для сопряжённого транспонирования A). Используется только ul треугольная часть (U для верхней, L для нижней) A. dA указывает, является ли A унитреугольной (диагональ предполагается равной единице, если U, или не-унитреугольной, если N).

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

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

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

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

Функции LAPACK

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

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

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

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

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

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

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

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

gelqf!(A, tau)

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

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

END_OF_DOCUMENT_MARKER

gelqf!(A) → (A, tau)

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

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

geqlf!(A, tau)

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

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

geqlf!(A) → (A, tau)

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

geqrf!(A, tau)

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

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

geqrf!(A) → (A, tau)

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

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, который хранит элементарные отражатели.

gerqf!(A, tau)

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

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

gerqf!(A) → (A, tau)

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

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

geqrt3!(A, T)

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

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

geqrt3!(A) → (A, T)

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

getrf!(A) → (A, ipiv, info)

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

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

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

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

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.

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

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

END_OF_DOCUMENT_MARKER

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

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! без балансировки и транспонирования.

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

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

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

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

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

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.

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.

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.

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

ggev!(jobvl, jobvr, A, B) → (alpha, beta, vl, vr): Находит обобщённое собственное разложение A и B. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, соответствующие собственные векторы вычисляются.

gtsv!(dl, d, du, B)

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

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

gttrf!(dl, d, du) → (dl, d, du, du2, ipiv)

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

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

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.

orglq!(A, tau, k = length(tau)): Явно находит матрицу Q факторизации LQ после вызова gelqf! для A. Использует вывод функции gelqf!. A перезаписывается Q.

orgqr!(A, tau, k = length(tau)): Явно находит матрицу Q факторизации QR после вызова geqrf! для A. Использует вывод функции geqrf!. A перезаписывается Q.

orgql!(A, tau, k = length(tau)): Явно находит матрицу Q факторизации QL после вызова geqlf! для A. Использует вывод функции geqlf!. A перезаписывается Q.

orgrq!(A, tau, k = length(tau)): Явно находит матрицу Q факторизации RQ после вызова gerqf! для A. Использует вывод функции gerqf!. A перезаписывается Q.

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 перезаписывается.

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 перезаписывается.

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 перезаписывается.

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 перезаписывается.

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 перезаписывается.

posv!(uplo, A, B) → (A, B): Находит решение A * X = B, где A — симметричная или эрмитова положительно определённая матрица. Если uplo = U, вычисляется верхняя треугольная декомпозиция Холецкого A. Если uplo = L, вычисляется нижняя треугольная декомпозиция Холецкого A. A перезаписывается своим разложением Холецкого. B перезаписывается решением X.

potrf!(uplo, A): Вычисляет разложение Холецкого (верхнее, если uplo = U, нижнее, если uplo = L) положительно определённой матрицы A. A перезаписывается и возвращается с кодом состояния.

potri!(uplo, A)

Вычисляет обратную матрицу A после вызова potrf! для нахождения её (верхнего, если uplo = U, нижнего, если uplo = L) разложения Холецкого.

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

potrs!(uplo, A, B): Находит решение A * X = B, где A — симметричная или эрмитова положительно определённая матрица, чьё разложение Холецкого было вычислено функцией potrf!. Если uplo = U, была вычислена верхняя треугольная декомпозиция Холецкого A. Если uplo = L, была вычислена нижняя треугольная декомпозиция Холецкого A. B перезаписывается решением X.

pstrf!(uplo, A, tol) → (A, piv, rank, info)

Вычисляет (верхнее, если uplo = U, нижнее, если uplo = L) разложение Холецкого с выбором опор (pivot) положительно определённой матрицы A с заданной пользователем толерантностью tol. A перезаписывается разложением Холецкого.

Возвращает A, опорные элементы piv, ранг A, и код состояния. Если info = 0, факторизация выполнена успешно. Если info = i > 0, то A не является положительно определённой или имеет недостаточный ранг.

ptsv!(D, E, B): Решает A * X = B для положительно определённой трёхдиагональной матрицы A. D — диагональ A, а E — внедиагональ. B перезаписывается решением X и возвращается.

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

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

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

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.

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

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.

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 - ошибка назад, каждая покомпонентно.

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

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

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.

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

syconv!(uplo, A, ipiv) → (A, work): Преобразует симметричную матрицу A (которая была факторизована в треугольную матрицу) в две матрицы L и D. Если uplo = U, A является верхней треугольной. Если uplo = L, она является нижней треугольной. ipiv - это вектор поворота из треугольного разложения. A перезаписывается L и D.

sysv!(uplo, A, B) → (B, A, ipiv): Находит решение A * X = B для симметричной матрицы A. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина. B перезаписывается решением X. A перезаписывается факторизацией Bunch-Kaufman. ipiv содержит информацию о повороте в факторизации.

sytrf!(uplo, A) → (A, ipiv, info)

Вычисляет факторизацию Bunch-Kaufman симметричной матрицы A. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина.

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

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

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

hesv!(uplo, A, B) → (B, A, ipiv): Находит решение A * X = B для эрмитовой матрицы A. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина. B перезаписывается решением X. A перезаписывается факторизацией Bunch-Kaufman. ipiv содержит информацию о повороте в факторизации.

hetrf!(uplo, A) → (A, ipiv, info)

Вычисляет факторизацию Bunch-Kaufman эрмитовой матрицы A. Если uplo = U, верхняя половина A хранится. Если uplo = L, хранится нижняя половина.

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

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

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

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.

sygvd!(jobz, range, uplo, A, vl, vu, il, iu, abstol) → (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.

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.

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.

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

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

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

gees!(jobvs, A) → (A, vs, w)

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

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

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

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

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

trexc!(compq, ifst, ilst, T, Q) → (T, Q): Переупорядочивает факторизацию Шюра матрицы. Если compq = V, векторы Шюра Q переупорядочиваются. Если compq = N, они не изменяются. ifst и ilst задают переупорядочивание векторов.

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.

tgsen!(select, S, T, Q, Z) → (S, T, alpha, beta, Q, Z): Переупорядочивает векторы обобщенного разложения Шюра. select задает собственные значения в каждом кластере.

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.

© 2009–2016 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
https://docs.julialang.org/en/release-0.5/stdlib/linalg/