Документация Engee

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

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

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

julia> tr(A)
3

julia> det(A)
104.0

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

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

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

julia> eigvals(A)
2-element Vector{ComplexF64}:
 -1.0 - 5.0im
 -1.0 + 5.0im

julia> eigvecs(A)
2×2 Matrix{ComplexF64}:
  0.945905-0.0im        0.945905+0.0im
 -0.166924+0.278207im  -0.166924-0.278207im

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

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

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

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

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

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

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

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

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

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

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

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

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

julia> sB\x
3-element Vector{Float64}:
 -1.7391304347826084
 -1.1086956521739126
 -1.4565217391304346

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

Особые матрицы

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

Сведения об особых типах матриц, реализованных в Julia, а также о наличии перехватчиков к оптимизированным для них методам в LAPACK приведены в таблицах ниже.

Type Description

Symmetric

Симметричная матрица

Hermitian

Эрмитова матрица

UpperTriangular

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

UnitUpperTriangular

Верхняя треугольная матрица с единичной диагональю

LowerTriangular

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

UnitLowerTriangular

Нижняя треугольная матрица с единичной диагональю

UpperHessenberg

Верхняя матрица Хессенберга

Tridiagonal

Трехдиагональная матрица

SymTridiagonal

Симметричная трехдиагональная матрица

Bidiagonal

Верхняя/нижняя бидиагональная матрица

Diagonal

Диагональная матрица

UniformScaling

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

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

Matrix type + - * \ Other functions with optimized methods

Symmetric

MV

inv, sqrt, cbrt, exp

Hermitian

MV

inv, sqrt, cbrt, exp

UpperTriangular

MV

MV

inv, det, logdet

UnitUpperTriangular

MV

MV

inv, det, logdet

LowerTriangular

MV

MV

inv, det, logdet

UnitLowerTriangular

MV

MV

inv, det, logdet

UpperHessenberg

MM

inv, det

SymTridiagonal

M

M

MS

MV

eigmax, eigmin

Tridiagonal

M

M

MS

MV

Bidiagonal

M

M

MS

MV

Diagonal

M

M

MV

MV

inv, det, logdet, /

UniformScaling

M

M

MVS

MVS

/

Условные обозначения

Знак Описание

М (матрица)

Доступен оптимизированный метод для операций над двумя матрицами

В (вектор)

Доступен оптимизированный метод для операций над матрицей и вектором

С (скаляр)

Доступен оптимизированный метод для операций над матрицей и скаляром

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

Matrix type LAPACK eigen eigvals eigvecs svd svdvals

Symmetric

SY

ARI

Hermitian

HE

ARI

UpperTriangular

TR

A

A

A

UnitUpperTriangular

TR

A

A

A

LowerTriangular

TR

A

A

A

UnitLowerTriangular

TR

A

A

A

SymTridiagonal

ST

A

ARI

AV

Tridiagonal

GT

Bidiagonal

BD

A

A

Diagonal

DI

A

Условные обозначения

Знак Описание Пример

О (общий)

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

например eigvals(M)

Д (диапазон)

Доступен оптимизированный метод для нахождения собственных значений в диапазоне с il по ih

eigvals(M, il, ih)

И (интервал)

Доступен оптимизированный метод для нахождения собственных значений в интервале [vl, vh]

eigvals(M, vl, vh)

В (векторы)

Доступен оптимизированный метод для нахождения собственных векторов, соответствующих собственным значениям x=[x1, x2,...]

eigvecs(M, x)

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

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

Пример работы оператора UniformScaling:

julia> U = UniformScaling(2);

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

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

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

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

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

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

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

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

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

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

Тип Описание

BunchKaufman

Разложение Банча-Кауфман

Cholesky

Разложение Холецкого

CholeskyPivoted

Разложение Холецкого с выбором ведущего элемента

LDLt

LDL(T)-разложение

LU

LU-разложение

QR

QR-разложение

QRCompactWY

Компактная WY-форма QR-разложения

QRPivoted

QR-разложение с выбором ведущего элемента

LQ

QR-разложение для transpose(A)

Hessenberg

Разложение Хессенберга

Eigen

Спектральное разложение

GeneralizedEigen

Обобщенное спектральное разложение

SVD

Сингулярное разложение

GeneralizedSVD

Обобщенное сингулярное разложение

Schur

Разложение Шура

GeneralizedSchur

Обобщенное разложение Шура

Сопряжения и транспонирования объектов Factorization в отложенном режиме заключаются в объекты AdjointFactorization и TransposeFactorization, соответственно. В общем случае транспонирования вещественных объектов Factorization заключаются в оболочку как AdjointFactorization.

Ортогональные матрицы (AbstractQ)

Некоторые разложения матриц порождают ортогональные/унитарные «матричные» коэффициенты. К этим разложениям относятся QR-разложения, полученные из вызовов функции qr, т. е. QR, QRCompactWY и QRPivoted, разложение Хессенберга, полученное из вызовов hessenberg, LQ-разложение, полученное из lq. Хотя эти ортогональные/унитарные коэффициенты допускают матричное представление, их внутреннее представление отличается (по соображениям производительности и памяти). Следовательно, их следует рассматривать скорее как основанные на функциях линейные операторы с поддержкой матриц. В частности, чтение, например столбца из его матричного представления требует выполнения кода «матрично-векторного умножения», а не простого считывания данных из памяти (возможно, с заполнением части вектора структурными нулями). Еще одно явное отличие от других нетреугольных типов матриц заключается в том, что код умножения позволяет изменять матрицу на месте во время умножения. Кроме того, объекты определенных подтипов AbstractQ, созданные с помощью qr, hessenberg и lq, могут вести себя как квадратная или прямоугольная матрица в зависимости от контекста:

julia> using LinearAlgebra

julia> Q = qr(rand(3,2)).Q
3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}

julia> Matrix(Q)
3×2 Matrix{Float64}:
 -0.320597   0.865734
 -0.765834  -0.475694
 -0.557419   0.155628

julia> Q*I
3×3 Matrix{Float64}:
 -0.320597   0.865734  -0.384346
 -0.765834  -0.475694  -0.432683
 -0.557419   0.155628   0.815514

julia> Q*ones(2)
3-element Vector{Float64}:
  0.5451367118802273
 -1.241527373086654
 -0.40179067589600226

julia> Q*ones(3)
3-element Vector{Float64}:
  0.16079054743832022
 -1.674209978965636
  0.41372375588835797

julia> ones(1,2) * Q'
1×3 Matrix{Float64}:
 0.545137  -1.24153  -0.401791

julia> ones(1,3) * Q'
1×3 Matrix{Float64}:
 0.160791  -1.67421  0.413724

Благодаря этому отличию от плотных или структурированных матриц абстрактный тип AbstractQ не является подтипом AbstractMatrix, а имеет собственную иерархию типов. Пользовательские типы с подтипом AbstractQ могут полагаться на универсальные резервные варианты, если выполняются следующие условия. Например, для

struct MyQ{T} <: LinearAlgebra.AbstractQ{T}
    # обязательные поля
end

укажите перегрузки для

Base.size(Q::MyQ) # размер соответствующего представления квадратной матрицы
Base.convert(::Type{AbstractQ{T}}, Q::MyQ) # продвижение типа элементов [необязательно]
LinearAlgebra.lmul!(Q::MyQ, x::AbstractVecOrMat) # левое умножение
LinearAlgebra.rmul!(A::AbstractMatrix, Q::MyQ) # правое умножение

Если продвижение eltype не представляет интереса, метод convert не нужен, так как по умолчанию convert(::Type{AbstractQ{T}}, Q::AbstractQ{T}) возвращает сам Q. Сопряжения AbstractQ-типизированных объектов в отложенном режиме заключаются в тип оболочки AdjointQ, для которого требуются собственные методы LinearAlgebra.lmul! и LinearAlgebra.rmul!. С таким набором методов любое выражение Q::MyQ можно использовать как матрицу, предпочтительно в контексте умножения: работает все — умножение посредством * со скалярами, векторами и матрицами слева и справа, получение матричного представления Q с помощью Matrix(Q) (или Q*I) и индексирование в матричное представление. Напротив, сложение и вычитание, а также трансляция элементов в матричном представлении не работают, поскольку это было бы крайне неэффективно. Для таких случаев следует заранее вычислить матричное представление и кэшировать его для последующего использования.

Стратегии выбора главного элемента

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

Сначала на основе стратегии выбора главного элемента выбирается главный элемент с хорошими числовыми характеристиками. Затем строки и столбцы исходной матрицы переставляются так, чтобы выбранный элемент оказался на месте для последующих вычислений. Более того, этот процесс повторяется для каждого этапа разложения.

Следовательно, помимо обычных матричных коэффициентов, выходные данные схем факторизации с выбранным главным элементом также содержат матрицы перестановок.

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

См. также описание макроса LinearAlgebra.ZeroPivotException.

NoPivot

Выбор главного элемента не выполняется. Разложения матриц, такие как LU-разложение, могут не работать без выбора главного элемента, а также могут быть численно неустойчивыми для матриц с плавающей запятой из-за ошибок округления. Такая стратегия выбора главного элемента полезна в основном в учебных целях.

RowNonZero

В качестве главного элемента выбирается первый ненулевой элемент в оставшихся строках.

Учтите, что для матриц с плавающей запятой итоговый алгоритм LU численно неустойчивый — эта стратегия полезна в основном для сравнения с вычислениями вручную (в которых она обычно применяется) или для других алгебраических типов (например, рациональных чисел), не подверженных ошибкам округления. В других случаях при использовании гауссова исключения следует предпочесть стратегию выбора главного элемента по умолчанию RowMaximum.

Обратите внимание, что eltype матрицы должен допускать метод iszero.

RowMaximum

В качестве главного элемента выбирается элемент максимальной величины в оставшихся строках. Это стратегия по умолчанию для LU-разложения матриц с плавающей запятой. Иногда ее называют алгоритмом «частичного выбора главного элемента».

Обратите внимание, что eltype матрицы должен допускать метод abs, тип результата которого должен поддерживать метод <.

ColumnNorm

Для последующих вычислений используется столбец с максимальной нормой. Применяется для QR-разложения.

Обратите внимание, что eltype матрицы должен допускать методы norm и abs, типы результатов которых должны поддерживать метод <.

Standard functions

Linear algebra functions in Julia are largely implemented by calling functions from LAPACK. Sparse matrix factorizations call functions from SuiteSparse. Other sparse solvers are available as Julia packages.

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

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

Примеры

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1
*(A, B::AbstractMatrix, C)
A * B * C * D

Последовательное умножение 3 или 4 матриц выполняется в наиболее эффективном порядке, исходя из размеров массивов. То есть количество скалярных умножений, необходимых для (A * B) * C (с тремя плотными матрицами), сравнивается с количеством для A * (B * C) для выбора оптимального варианта.

Если последний множитель является вектором или первый — транспонированным вектором, то эффективнее сначала обработать их. В частности, x' * B * y означает (x' * B) * y для обычной хранящейся по столбцам матрицы B::Matrix. В отличие от dot(x, B, y), при этом выделяется память под промежуточный массив.

Если первый или последний множитель является числом, он будет объединен с матричным умножением с использованием метода mul! с 5 аргументами.

См. также описание muladd и dot.

Совместимость: Julia 1.7

Для этих оптимизаций требуется версия Julia не ниже 1.7.

 
\(A, B)

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

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

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

См. также описание factorize, pinv.

Примеры

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

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

julia> A * X == B
true
A / B

Правое деление матриц: выражение A / B эквивалентно (B' \ A')', где [\] — оператор левого деления. Для квадратных матриц результат X будет таким, что A == X*B.

См. также описание rdiv!.

Примеры

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true
SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

RankDeficientException

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

LAPACKException

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

dot(x, y)
x ⋅ y

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

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

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

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

Примеры

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

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

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

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

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

julia> dot(x, y)
150.0
dot(x, A, y)

Вычисляет обобщенное точечное произведение dot(x, A*y) двух векторов x и y без сохранения промежуточного результата A*y. Что касается функции dot(,) с двумя аргументами, она действует рекурсивно. Более того, для комплексных векторов первый вектор является сопряженным.

Совместимость: Julia 1.4

Для метода dot с тремя аргументами требуется версия Julia не ниже 1.4.

Примеры

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

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true
cross(x, y)
×(x,y)

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

Примеры

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

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

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0
axpy!(α, x::AbstractArray, y::AbstractArray)

Перезаписывает y результатом выражения x * α + y и возвращает y. Если у x и y имеют одинаковые оси, это равносильно выражению y .+= x .* a.

Примеры

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

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

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12
axpby!(α, x::AbstractArray, β, y::AbstractArray)

Перезаписывает y результатом выражения x * α + y * β и возвращает y. Если у x и y имеют одинаковые оси, это равносильно выражению y .= x .* a .+ y .* β.

Примеры

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

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

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18
rotate!(x, y, c, s)

Перезаписывает x результатом выражения c*x + s*y, а y — результатом выражения -conj(s)*x + c*y. Возвращает x и y.

Совместимость: Julia 1.5

Для rotate! требуется версия Julia не ниже 1.5.

 
reflect!(x, y, c, s)

Перезаписывает x результатом выражения c*x + s*y, а y — результатом выражения conj(s)*x - c*y. Возвращает x и y.

Совместимость: Julia 1.5

Для reflect! требуется версия Julia не ниже 1.5.

 
factorize(A)

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

Свойства A тип разложения

Положительно определенная

Разложение Холецкого (см. cholesky)

Плотная симметричная/эрмитова

Разложение Банча-Кауфмана (см. bunchkaufman)

Разреженная симметричная/эрмитова

LDLt-разложение (см. ldlt)

Треугольная

Треугольное разложение

Диагональная

Диагональное разложение

Двухдиагональная

Двухдиагональное разложение

Трехдиагональная

LU-разложение (см. lu)

Симметричная вещественная трехдиагональная

LDLt-разложение (см. ldlt)

Общая квадратная

LU-разложение (см. lu)

Общая неквадратная

QR-разложение (см. qr)

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

Примеры

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

julia> factorize(A) # Функция factorize проверит, разрежена ли уже матрица A
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

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

Diagonal(V::AbstractVector)

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

См. также описание типа UniformScaling для отложенной матрицы тождественности I, функции diagm для создания плотной матрицы и функции diag для извлечения диагональных элементов.

Примеры

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

julia> diagm([7, 13])
2×2 Matrix{Int64}:
 7   0
 0  13

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

Матрица из одного столбца не обрабатывается как вектор, а вместо этого вызывается метод Diagonal(A::AbstractMatrix), который извлекает одноэлементный diag(A):

 
julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0
Diagonal(A::AbstractMatrix)

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

Примеры

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

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

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

julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  5
Diagonal{T}(undef, n)

Создает неинициализированный вектор Diagonal{T} длиной n. См. описание undef.

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

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

Примеры

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

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

julia> Bu = Bidiagonal(dv, ev, :U) # ev находится на первой наддиагонали
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev находится на первой поддиагонали
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4
Bidiagonal(A, uplo::Symbol)

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

Примеры

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

julia> Bidiagonal(A, :U) # содержит главную диагональ и первую наддиагональ матрицы A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # содержит главную диагональ и первую поддиагональ матрицы A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4
SymTridiagonal(dv::V, ev::V) where V <: AbstractVector

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

Для блочных матриц SymTridiagonal элементы dv симметризируются. Аргумент ev интерпретируется как наддиагональ. Блоки из поддиагонали являются (материализованным) транспонированием соответствующих блоков наддиагонали.

Примеры

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

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

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

julia> A = SymTridiagonal(fill([1 2; 3 4], 3), fill([1 2; 3 4], 2));

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

julia> A[1,2]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[2,1]
2×2 Matrix{Int64}:
 1  3
 2  4
SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]
Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

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

Поддиагональ dl и наддиагональ du не должны быть псевдонимами друг для друга. Если обнаружены псевдонимы, конструктор будет использовать копию du в качестве аргумента.

Примеры

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

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

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

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

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

Примеры

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

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4
Symmetric(A::AbstractMatrix, uplo::Symbol=:U)

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

Представления Symmetric в основном полезны для вещественно-симметричных матриц, для которых доступны специализированные алгоритмы (например, для задач на собственные значения) для типов Symmetric. См. также описание типа Hermitian(A) для эрмитовых матриц A == A', который фактически эквивалентен Symmetric для вещественных матриц, но также полезен для комплексных матриц. (Комплексные матрицы Symmetric поддерживаются, но для них существует мало специализированных алгоритмов, если они вообще есть.)

Чтобы вычислить симметричную часть вещественной матрицы или, в более общем случае, эрмитову часть (A + A') / 2 вещественной или комплексной матрицы A, используйте hermitianpart.

Примеры

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

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

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

Hermitian(A::AbstractMatrix, uplo::Symbol=:U)

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

Для вычисления эрмитовой части A используйте hermitianpart.

Примеры

julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
 1+0im  2+2im  3-3im
 4+0im  5+0im  6-6im
 7+0im  8+8im  9+0im

julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

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

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

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

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

Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)
LowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

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

Примеры

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

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

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

Примеры

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

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0
UnitUpperTriangular(A::AbstractMatrix)

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

Примеры

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

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0
UpperHessenberg(A::AbstractMatrix)

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

Совместимость: Julia 1.3

Этот тип был добавлен в Julia 1.3.

Для H \ b, det(H) и подобного реализованы эффективные алгоритмы.

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

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

При итерации по разложению создаются множители F.Q и F.H.

Примеры

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

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

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

Совместимость: Julia 1.6

Индексирование с использованием диапазонов впервые реализовано в Julia 1.6.

Примеры

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

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

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

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0
I

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

Примеры

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

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im
(I::UniformScaling)(n::Integer)

Создает матрицу Diagonal из UniformScaling.

Совместимость: Julia 1.2

Этот метод впервые реализован в Julia 1.2.

Примеры

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7
LinearAlgebra.Factorization

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

LU <: Factorization

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

Доступ к отдельным компонентам разложения F::LU можно получить с помощью функции getproperty.

Компонент Описание

F.L

L (нижняя унитреугольная) часть LU

F.U

U (верхнетреугольная) часть LU

F.p

Vector (правой) перестановки

F.P

Matrix (правой) перестановки

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

Примеры

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

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

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

julia> l, u, p = lu(A); # деструктурирование через итерацию

julia> l == F.L && u == F.U && p == F.p
true
lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

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

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

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

Перестановкой q может быть либо перестановочный вектор, либо nothing. Если перестановочный вектор не указан или q имеет значение nothing, используется принятый по умолчанию в UMFPACK вариант. Если перестановка не начинается с нуля, создается копия с отсчетом от нуля.

Вектор control по умолчанию соответствует конфигурации пакета Julia SparseArrays по умолчанию для UMFPACK (она отличается от конфигурации UMFPACK по умолчанию для отключения итеративного уточнения), но его можно изменить, передав вектор длиной UMFPACK_CONTROL. Возможные конфигурации см. в руководстве по UMFPACK. Например, чтобы снова включить итеративное уточнение, сделайте следующее:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # считываем конфигурацию Julia по умолчанию для разреженной матрицы типа Float64
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # необязательно — выводим значения
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # снова включаем итеративное уточнение (шаг 2 процесса итеративного уточнения максимума UMFPACK по умолчанию)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # решаем Ax = b, включая итеративное уточнение UMFPACK

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

Компонент Описание

L

L (нижняя унитреугольная) часть LU

U

U (верхнетреугольная) часть LU

p

Vector правой перестановки

q

Vector левой перестановки

Rs

Vector коэффициентов масштабирования

:

Компоненты (L,U,p,q,Rs)

Между F и A существует следующее отношение:

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

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

См. также описание lu!.

lu(A::AbstractSparseMatrixCSC) использует библиотеку UMFPACK[1], которая является частью SuiteSparse. Поскольку эта библиотека поддерживает только разреженные матрицы с элементами Float64 или ComplexF64, lu преобразует A в копию с типом SparseMatrixCSC{Float64} или SparseMatrixCSC{ComplexF64} в зависимости от ситуации.

 
lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU

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

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

По умолчанию при check = true ошибка также выдается, когда разложение дает допустимые множители, но верхнетреугольный множитель U имеет неполный ранг. Это можно изменить путем передачи allowsingular = true.

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

Как правило, LU-разложение предполагает перестановку строк матрицы (что соответствует выходным данным F.p, описанным ниже), известную как «выбор главного элемента» (так как по сути выбирается строка, содержащая «главный элемент», то есть диагональный элемент F.U). С помощью необязательного аргумента pivot можно выбрать одну из следующих стратегий выбора главного элемента.

  • RowMaximum() (по умолчанию): стандартная стратегия выбора главного элемента; главный элемент соответствует элементу с максимальным абсолютным значением среди оставшихся строк, подлежащих разложению. Такая стратегия выбора главного элемента требует, чтобы тип элемента также поддерживал abs и <. (This is generally the only numerically stable option for floating-point матрицы.

  • RowNonZero(): главный элемент соответствует первому ненулевому элементу среди оставшихся строк, подлежащих разложению. (Это обычный вариант при вычислениях вручную. Он также полезен для более общих алгебраических числовых типов, которые поддерживают iszero, но не abs или <.)

  • NoPivot(): выбор главных элементов отключен (если в позиции главного элемента встретится нулевой элемент, произойдет ошибка даже при allowsingular = true).

Доступ к отдельным компонентам разложения F можно получить с помощью функции getproperty.

Компонент Описание

F.L

L (нижняя унитреугольная) часть LU

F.U

U (верхнетреугольная) часть LU

F.p

Vector (правой) перестановки

F.P

Matrix (правой) перестановки

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

Между F и A существует следующее отношение:

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

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

Поддерживаемая функция LU LU{T,Tridiagonal{T}}

/

✓

\

✓

✓

inv

✓

✓

det

✓

✓

logdet

✓

✓

logabsdet

✓

✓

size

✓

✓
Совместимость: Julia 1.11

Именованный аргумент allowsingular был добавлен в Julia 1.11.

Примеры

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

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

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

julia> l, u, p = lu(A); # деструктурирование через итерацию

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0
lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

Вычисляет LU-разложение разреженной матрицы A, повторно используя символическое разложение уже существующего LU-разложения, хранящегося в F. Если в аргументе reuse_symbolic не передано значение false, разреженная матрица A должна иметь тот же ненулевой шаблон, что и матрица, используемая для создания LU-разложения F (в противном случае возникнет ошибка). Если A и F имеют разный размер, размер всех векторов изменится соответствующим образом.

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

Перестановкой q может быть либо перестановочный вектор, либо nothing. Если перестановочный вектор не указан или q имеет значение nothing, используется принятый по умолчанию в UMFPACK вариант. Если перестановка не основана на нулевом элементе, создается копия на основе нулевого элемента.

См. также описание lu.

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC) использует библиотеку UMFPACK, которая является частью SuiteSparse. Поскольку эта библиотека поддерживает только разреженные матрицы с элементами Float64 или ComplexF64, lu! автоматически преобразует типы в определенные для LU-разложения или SparseMatrixCSC{ComplexF64} в зависимости от ситуации.
Совместимость: Julia 1.5

Для использования функции lu! применительно к UmfpackLU требуется версия Julia не ниже 1.5.

Примеры

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0
lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

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

Совместимость: Julia 1.11

Именованный аргумент allowsingular был добавлен в Julia 1.11.

Примеры

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

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

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

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

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

Треугольный множитель Холецкого можно получить из разложения F::Cholesky с помощью F.L и F.U, где A ≈ F.U' * F.U ≈ F.L * F.L'.

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

При итерации декомпозиции создаются компоненты L и U.

Примеры

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

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

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

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

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

julia> l, u = C; # деструктурирование через итерацию

julia> l == C.L && u == C.U
true
CholeskyPivoted

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

Треугольный множитель Холецкого можно получить из разложения F::CholeskyPivoted с помощью F.L и F.U и перестановки с помощью F.p, где A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' и с Ur = F.U[1:F.rank, :] и Lr = F.L[:, 1:F.rank], или альтернативно A ≈ Up' * Up ≈ Lp * Lp' с Up = F.U[1:F.rank, invperm(F.p)] и Lp = F.L[invperm(F.p), 1:F.rank].

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

При итерации декомпозиции создаются компоненты L и U.

Примеры

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # деструктурирование через итерацию

julia> l == C.L && u == C.U
true
cholesky(A, NoPivot(); check = true) -> Cholesky

Вычисляет разложение Холецкого для плотной симметричной положительно определенной матрицы A и возвращает разложение Cholesky. Матрица A может быть либо Symmetric, либо Hermitian AbstractMatrix, либо идеальной симметричной или эрмитовой AbstractMatrix.

Треугольный множитель Холецкого можно получить из разложения F с помощью F.L и F.U, где A ≈ F.U' * F.U ≈ F.L * F.L'.

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

Если у вас есть матрица A, которая не совсем является эрмитовой из-за ошибок округления при ее построении, заключите ее в Hermitian(A) перед передачей функции cholesky, чтобы она интерпретировалась как идеальная эрмитова.

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

Примеры

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

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

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

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

julia> C.L * C.U == A
true
cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

Вычисляет разложение Холецкого с выбранным главным элементом для плотной симметричной положительно полуопределенной матрицы A и возвращает разложение CholeskyPivoted. Матрица A может быть либо Symmetric, либо Hermitian AbstractMatrix, либо идеальной симметричной или эрмитовой AbstractMatrix.

Треугольный множитель Холецкого можно получить из разложения F с помощью F.L и F.U и перестановки с помощью F.p, где A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' и с Ur = F.U[1:F.rank, :] и Lr = F.L[:, 1:F.rank], или альтернативно A ≈ Up' * Up ≈ Lp * Lp' с Up = F.U[1:F.rank, invperm(F.p)] и Lp = F.L[invperm(F.p), 1:F.rank].

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

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

Если у вас есть матрица A, которая не совсем является эрмитовой из-за ошибок округления при ее построении, заключите ее в Hermitian(A) перед передачей функции cholesky, чтобы она интерпретировалась как идеальная эрмитова.

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

Примеры

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # деструктурирование через итерацию

julia> l == C.L && u == C.U
true
cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

Вычисляет разложение Холецкого для плотной положительно определенной матрицы A. Матрица A должна быть SparseMatrixCSC или представлением Symmetric/Hermitian матрицы SparseMatrixCSC. Обратите внимание, что даже если у матрицы A нет метки типа, она все равно должна быть симметричной или эрмитовой. Если perm не задано, используется перестановка, сокращающая заполнение. F = cholesky(A) чаще всего используется для решения систем уравнений с F\b, но для F также определены методы diag, det и logdet. Вы также можете извлекать отдельные множители из F с помощью F.L. Однако поскольку выбор главного элемента включен по умолчанию, разложение представлено как A == P'*L*L'*P с матрицей перестановки P. При использовании только L без учета P будут выдаваться неправильные ответы. Чтобы включить эффекты перестановки, обычно предпочтительнее извлекать «комбинированные» множители, такие как PtL = F.PtL (эквивалент P'*L) и LtP = F.UP (эквивалент L'*P).

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

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

Примеры

В следующем примере используется сокращающая заполнение перестановка [3, 2, 1]. Если в perm задано 1:3, чтобы не применять перестановку, количество ненулевых элементов в множителе равно 6.

julia> A = [2 1 1; 1 2 0; 1 0 2]
3×3 Matrix{Int64}:
 2  1  1
 1  2  0
 1  0  2

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

Этот метод использует библиотеку CHOLMOD[2][3] из SuiteSparse. CHOLMOD поддерживает только вещественные или комплексные типы с одинарной или двойной точностью. Входные матрицы, не относящиеся к этим типам элементов, будут при необходимости преобразованы в них.

 
Многие другие функции из CHOLMOD инкапсулированы, но не экспортируются из модуля `Base.SparseArrays.CHOLMOD`.
cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

То же, что и cholesky, но позволяет экономить дисковое пространство, перезаписывая входную матрицу A вместо создания копии. Если при разложении создается число, не представляемое типом элементов матрицы A, например для целочисленных типов, возникает исключение InexactError.

Примеры

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

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]
cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

То же, что и cholesky, но позволяет экономить дисковое пространство, перезаписывая входную матрицу A вместо создания копии. Если при разложении создается число, не представляемое типом элементов матрицы A, например для целочисленных типов, возникает исключение InexactError.

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

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

См. также описание cholesky.

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

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

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

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Возвращает разложение LDLt A + C*C' для разложения LDLt или LLt F матрицы A.

Возвращаемый множитель всегда представляет собой разложение LDLt.

См. также описание lowrankupdate!, lowrankdowndate и lowrankdowndate!.

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

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

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Возвращает разложение LDLt A + C*C' для разложения LDLt или LLt F матрицы A.

Возвращаемый множитель всегда представляет собой разложение LDLt.

См. также описание lowrankdowndate!, lowrankupdate и lowrankupdate!.

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

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

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

Обновляет разложение LDLt или LLt F матрицы A до разложения A + C*C'.

Разложения LLt преобразуются в LDLt.

См. также описание lowrankupdate, lowrankdowndate и lowrankdowndate!.

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

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

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

Обновляет разложение LDLt или LLt F матрицы A до разложения A - C*C'.

Разложения LLt преобразуются в LDLt.

См. также описание lowrankdowndate, lowrankupdate и lowrankupdate!.

LDLt <: Factorization

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

Доступ к отдельным компонентам разложения F::LDLt можно получить с помощью функции getproperty.

Компонент Описание

F.L

L (нижняя унитреугольная) часть LDLt

F.D

D (диагональная) часть LDLt

F.Lt

Lt (верхняя унитреугольная) часть LDLt

F.d

значения диагонали D в виде Vector

Примеры

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

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909
ldlt(S::SymTridiagonal) -> LDLt

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

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

Примеры

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

julia> ldltS = ldlt(S);

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

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255
ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

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

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

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

Этот метод использует библиотеку CHOLMOD[2][3] из SuiteSparse. CHOLMOD поддерживает только вещественные или комплексные типы с одинарной или двойной точностью. Входные матрицы, не относящиеся к этим типам элементов, будут при необходимости преобразованы в них.

 
Многие другие функции из CHOLMOD инкапсулированы, но не экспортируются из модуля `Base.SparseArrays.CHOLMOD`.
ldlt!(S::SymTridiagonal) -> LDLt

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

Примеры

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909
ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

Вычисляет -разложение матрицы A, повторно используя символическое разложение F. Матрица A должна быть SparseMatrixCSC или представлением Symmetric/Hermitian матрицы SparseMatrixCSC. Обратите внимание, что даже если у матрицы A нет метки типа, она все равно должна быть симметричной или эрмитовой.

См. также описание ldlt.

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

 
QR <: Factorization

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

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

При итерации декомпозиции создаются компоненты Q и R.

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

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

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

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

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

QRCompactWY <: Factorization

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

где  — это ортогональная или унитарная матрица, а  — верхнетреугольная. Это аналогично формату QR, за исключением того, что ортогональная или унитарная матрица хранится в формате Compact WY [4]. Для размера блока она хранится как нижняя трапецеидальная матрица m×n и матрица composed of верхнетреугольных матриц размером ×$n_b$ ( ) и верхней трапецеидальной матрицы ×$\min(m,n) - (b-1) n_b$ matrix ( ), верхняя квадратная часть которой, обозначенная , удовлетворяет выражению

так что является -м столбцом матрицы , является -м элементом [diag(T_1); diag(T_2); …; diag(T_b)], а является левым блоком m×min(m, n) матрицы . При создании с использованием qr размер блока задается с помощью .

При итерации декомпозиции создаются компоненты Q и R.

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

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

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

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

  • T является матрицей на , как описано выше. Элементы поддиагонали для каждой треугольной матрицы игнорируются.

Этот формат не следует путать с более старым представлением WY [5].

 
QRPivoted <: Factorization

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

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

При итерации декомпозиции создаются компоненты Q, R и p.

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

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

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

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

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

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

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

Вычисляет QR-разложение разреженной матрицы A. Используются сокращающие заполнение перестановки строк и столбцов, так что F.R = F.Q'*A[F.prow,F.pcol]. Основным применением данного типа является решение задач методом наименьших квадратов или недоопределенных задач с \. Функция вызывает SPQR[6] библиотеки C.

qr(A::SparseMatrixCSC) использует библиотеку SPQR, которая является частью SuiteSparse. Поскольку эта библиотека поддерживает только разреженные матрицы с элементами Float64 или ComplexF64, начиная с версии Julia 1.4 qr преобразует A в копию с типом SparseMatrixCSC{Float64} или SparseMatrixCSC{ComplexF64} в зависимости от ситуации.

Примеры

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Row permutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Column permutation:
2-element Vector{Int64}:
 1
 2
qr(A, pivot = NoPivot(); blocksize) -> F

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

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

  • Если pivot == ColumnNorm(), то F является объектом QRPivoted.

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

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

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

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

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

  • F.p: вектор перестановки главного элемента (только QRPivoted)

  • F.P: матрица перестановки главного элемента (только QRPivoted)

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

При итерации декомпозиции создаются компоненты Q, R и, если сохранился, p.

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

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

Размер блока для QR-разложения можно указать с помощью именованного аргумента blocksize :: Integer, когда pivot == NoPivot() и A isa StridedMatrix{<:BlasFloat}. Он игнорируется, когда blocksize > minimum(size(A)). См. описание QRCompactWY.

Совместимость: Julia 1.4

Для именованного аргумента blocksize требуется версия Julia не ниже 1.4.

Примеры

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

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

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

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

 
qr!(A, pivot = NoPivot(); blocksize)

Функция qr! аналогична функции qr, когда A является подтипом AbstractMatrix, но позволяет экономить дисковое пространство, перезаписывая входную матрицу A вместо создания копии. Если при разложении создается число, не представляемое типом элементов матрицы A, например для целочисленных типов, возникает исключение InexactError.

Совместимость: Julia 1.4

Для именованного аргумента blocksize требуется версия Julia не ниже 1.4.

Примеры

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

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

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

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

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

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

При итерации декомпозиции создаются компоненты S.L и S.Q.

Примеры

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

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

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

julia> l, q = S; # деструктурирование через итерацию

julia> l == S.L &&  q == S.Q
true
lq(A) -> S::LQ

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

При итерации декомпозиции создаются компоненты S.L и S.Q.

LQ-декомпозиция является QR-декомпозицией transpose(A) и полезна для вычисления решения методом минимальных норм lq(A) \ b для недостаточно определенной системы уравнений (A имеет больше столбцов, чем строк, но имеет полный строчный ранг).

Примеры

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

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

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

julia> l, q = S; # деструктурирование через итерацию

julia> l == S.L &&  q == S.Q
true
lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A внутренним образом инкапсулируется Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # деструктурирование через итерацию

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

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1
bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

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

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

Если rook имеет значение true, используется ладейный выбор главного элемента. Если rook имеет значение false, ладейный выбор главного элемента не используется.

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

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

Примеры

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

julia> S = bunchkaufman(A) # A внутренним образом инкапсулируется Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # деструктурирование через итерацию

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

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

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

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0
bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

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

Eigen <: Factorization

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

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

При итерации декомпозиции создаются компоненты F.values и F.vectors.

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # деструктурирование через итерацию

julia> vals == F.values && vecs == F.vectors
true
GeneralizedEigen <: Factorization

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

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

При итерации декомпозиции создаются компоненты F.values и F.vectors.

Примеры

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

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

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # деструктурирование через итерацию

julia> vals == F.values && vecs == F.vectors
true
eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

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

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

Примеры

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

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

Для скалярных входных данных eigvals вернет скаляр.

Примеры

julia> eigvals(-2)
-2
eigvals(A, B) -> values

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

Примеры

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

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

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

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

Примеры

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

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

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

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

Примеры

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

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

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259
eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

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

Входная матрица A не будет содержать собственные значения после вызова eigvals!. A используется в качестве рабочей области.

Примеры

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

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

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228
eigvals!(A, B; sortby) -> values

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

Входные матрицы A и B не будут содержать собственные значения после вызова eigvals!. Они используются как рабочие области.

Примеры

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

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

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

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

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

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

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

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

Примеры

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

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

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

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291
eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

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

Примеры

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0
eigvecs(A, B) -> Matrix

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

Примеры

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

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

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im
eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

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

При итерации декомпозиции создаются компоненты F.values и F.vectors.

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

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

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

Примеры

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # деструктурирование через итерацию

julia> vals == F.values && vecs == F.vectors
true
eigen(A, B; sortby) -> GeneralizedEigen

Вычисляет декомпозицию обобщенных собственных значений матриц A и B, возвращая объект разложения GeneralizedEigen F, который содержит обобщенные собственные значения в F.values, а обобщенные собственные векторы — в столбцах матрицы F.vectors. Это соответствует решению задачи нахождения обобщенных собственных значений вида Ax = λBx, где A, B — матрицы, x — собственный вектор, а λ — собственное значение. (k-й обобщенный собственный вектор можно получить из среза F.vectors[:, k].)

При итерации декомпозиции создаются компоненты F.values и F.vectors.

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

Примеры

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

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

julia> F = eigen(A, B);

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # деструктурирование через итерацию

julia> vals == F.values && vecs == F.vectors
true
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

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

При итерации декомпозиции создаются компоненты F.values и F.vectors.

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

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

Если irange не имеет значение 1:n, где n — это измерение матрицы A, возвращаемое разложение будет усеченным.

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

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

При итерации декомпозиции создаются компоненты F.values и F.vectors.

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

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

Если [vl, vu] не содержит все собственные значения матрицы A, возвращаемое разложение будет усеченным.

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

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

Hessenberg <: Factorization

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

hessenberg(A) -> Hessenberg

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

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

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

При итерации разложения создаются множители F.Q, F.H, F.μ.

Примеры

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

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

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

julia> q, h = F; # деструктурирование через итерацию

julia> q == F.Q && h == F.H
true
hessenberg!(A) -> Hessenberg

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

Schur <: Factorization

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

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

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

Примеры

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

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

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

julia> t, z, vals = F; # деструктурирование через итерацию

julia> t == F.T && z == F.Z && vals == F.values
true
GeneralizedSchur <: Factorization

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

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

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

schur(A) -> F::Schur

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

Для вещественной матрицы A разложение Шура является «квазитреугольным», что означает, что оно является верхнетреугольным, за исключением диагональных блоков 2×2 для любой сопряженной пары комплексных собственных значений, что позволяет разложению быть чисто вещественным даже при наличии комплексных собственных значений. Для получения (комплексного) чисто верхнетреугольного разложения Шура из вещественного квазитреугольного разложения можно использовать Schur{Complex}(schur(A)).

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

Примеры

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

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

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

julia> t, z, vals = F; # деструктурирование через итерацию

julia> t == F.T && z == F.Z && vals == F.values
true
schur(A, B) -> F::GeneralizedSchur

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

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

schur!(A) -> F::Schur

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

Примеры

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

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

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

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

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

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

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

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

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

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

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

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

SVD <: Factorization

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

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

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

Примеры

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

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

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

julia> u, s, v = F; # деструктурирование через итерацию

julia> u == F.U && s == F.S && v == F.V
true
GeneralizedSVD <: Factorization

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

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

  • U является ортогональной матрицей M на M;

  • V является ортогональной матрицей P на P;

  • Q является ортогональной матрицей N на N;

  • D1 является диагональной матрицей M на (K+L) с единицами в первых K элементах;

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

  • R0 является матрицей (K+L) на N, крайний правый блок которой (K+L) на (K+L), представляет собой несингулярный верхний блок треугольной формы;

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

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

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

Примеры

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

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

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

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

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 -0.0  1.0
  1.0  0.0
svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

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

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

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

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

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

Совместимость: Julia 1.3

Для именованного аргумента alg требуется версия Julia не ниже 1.3.

Примеры

julia> A = rand(4,3);

julia> F = svd(A); # Сохраняет объект разложения

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # деструктурирование через итерацию

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # Сохраняет только U

julia> Uonly == U
true
svd(A, B) -> GeneralizedSVD

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

  • U является ортогональной матрицей M на M;

  • V является ортогональной матрицей P на P;

  • Q является ортогональной матрицей N на N;

  • D1 является диагональной матрицей M на (K+L) с единицами в первых K элементах;

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

  • R0 является матрицей (K+L) на N, крайний правый блок которой (K+L) на (K+L), представляет собой несингулярный верхний блок треугольной формы;

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

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

Обобщенная SVD используется в приложениях, например, когда требуется сравнить, какое количество принадлежит A, а какое — B, как в случае сравнения генома человека и дрожжей, или сигнала и шума, или между кластерами и в составе кластеров. (См. обсуждение Эдельмана (Edelman) и Ванга (Wang): https://arxiv.org/abs/1901.00485)

Она раскладывает [A; B] на [UC; VS]H, где [UC; VS] — естественная ортогональная база для пространства столбцов [A; B], а H = RQ' — естественная неортогональная база для пространства строк [A;B], где верхние строки наиболее тесно связаны с матрицей A, а нижние — с матрицей B. Мультикосинусные/синусоидальные матрицы C и S обеспечивают мультиизмерение объема A по отношению к объему B, а U и V указывают направления, в которых они измеряются.

Примеры

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true
svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

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

svd!(A, B) -> GeneralizedSVD

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

svdvals(A)

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

Примеры

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

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

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

Примеры

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

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

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

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

svdvals!(A, B)

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

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

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

См. также описание givens.

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

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

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

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

y = G*x

имеет свойство, когда

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

См. также описание LinearAlgebra.Givens.

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

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

B = G*A

имеет свойство, когда

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

См. также описание LinearAlgebra.Givens.

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

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

B = G*x

имеет свойство, когда

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

См. также описание LinearAlgebra.Givens.

triu(M)

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

Примеры

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

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0
triu(M, k::Integer)

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

Примеры

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

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

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
triu!(M)

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

triu!(M, k::Integer)

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

Примеры

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

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

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

Примеры

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

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0
tril(M, k::Integer)

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

Примеры

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

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

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0
tril!(M)

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

tril!(M, k::Integer)

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

Примеры

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

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

Диапазон AbstractRange, задающий индексы k-й диагонали матрицы M. При необходимости можно указать стиль индекса, который определяет тип возвращаемого диапазона. Если indstyle isa IndexLinear (по умолчанию), возвращается AbstractRange{Integer}. С другой стороны, если indstyle isa IndexCartesian, то возвращается AbstractRange{CartesianIndex{2}}.

Если аргумент k не задан, предполагается значение 0 (что соответствует главной диагонали).

См. также описание diag, diagm, Diagonal.

Примеры

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

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

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)
Совместимость: Julia 1.11

Для указания IndexStyle требуется версия Julia не ниже 1.11.

 
diag(M, k::Integer=0)

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

См. также описание diagm, diagind, Diagonal и isdiag.

Примеры

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

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6
diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

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

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

Примеры

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

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

julia> diagm(1 => [1,2,3], 1 => [1,2,3])
4×4 Matrix{Int64}:
 0  2  0  0
 0  0  4  0
 0  0  0  6
 0  0  0  0
diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

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

Примеры

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3
rank(::QRSparse{Tv,Ti}) -> Ti

Возвращает ранг QR-разложения.

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

Определяет ранг S, вычисляя QR-разложение. Значения меньше tol считаются нулевыми. См. руководство по SPQR.

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

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

Числовой ранг может быть чувствительной и неточной характеристикой плохо обусловленных матриц с сингулярными значениями, близкими к пороговому допуску max(atol, rtol*σ₁). В таких случаях небольшие возмущения при вычислении сингулярных значений или в матрице могут изменить результат rank, выведя одно или несколько сингулярных значений за пороговое значение. Эти отклонения могут возникать даже из-за различий в ошибках с плавающей запятой между различными версиями Julia, архитектурами, компиляторами или операционными системами.
Совместимость: Julia 1.1

Для именованных аргументов atol и rtol требуется версия Julia не ниже 1.1. В Julia 1.0 rtol является позиционным аргументом, который будет устаревшим (нерекомендуемым) в Julia 2.0.

Примеры

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

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

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

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

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1
norm(A, p::Real=2)

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

p-норма определяется следующим образом:

где  — элементы , $

a_i

$ — норма (norm) , а  — длина . Поскольку p-норма вычисляется с помощью норм (norm) элементов A, p-норма вектора векторов не может интерпретироваться в общем случае как блочный вектор при p != 2.

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

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

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

Примеры

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

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

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

julia> norm(1:9)
16.881943016134134

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

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

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true
norm(x::Number, p::Real=2)

Для чисел возвращает $\left(

x

^p \right)^{1/p}$.

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0
opnorm(A::AbstractMatrix, p::Real=2)

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

Если p=1, операторной нормой является максимальная абсолютная сумма столбцов матрицы A:

где  — элементы матрицы , а и  — ее измерения.

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

Если p=Inf, операторной нормой является максимальная абсолютная сумма строк матрицы A:

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0
opnorm(x::Number, p::Real=2)

Для чисел возвращает $\left(

x

^p \right)^{1/p}$. Это эквивалентно norm.

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

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0
normalize!(a::AbstractArray, p::Real=2)

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

normalize(a, p::Real=2)

Нормализует массив a так, что его p-норма равна единице, то есть norm(a, p) == 1. Для скалярных значений действует аналогично функции sign(a) за исключением того, что normalize(0) = NaN. См. также описание normalize!, norm и sign.

Примеры

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN
cond(M, p::Real=2)

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

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

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

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

tr(M)

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

Примеры

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

julia> tr(A)
5
det(M)

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

См. также описание logdet и logabsdet.

Примеры

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

julia> det(M)
2.0
logdet(M)

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

Примеры

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

julia> logdet(M)
0.6931471805599453

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

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

Примеры

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

julia> det(A)
-1.0

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

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)
inv(M)

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

Примеры

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

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

julia> M*N == N*M == Matrix(I, 2, 2)
true
pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0

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

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

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

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

Дополнительные сведения: [8], [9], [10], [11].

Примеры

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

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

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0
nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0

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

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

Примеры

julia> M = [1 0 0; 0 1 0; 0 0 0]
3×3 Matrix{Int64}:
 1  0  0
 0  1  0
 0  0  0

julia> nullspace(M)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

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

julia> nullspace(M, atol=0.95)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0
kron(A, B)

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

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

Примеры

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

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

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

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

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

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10
kron!(C, A, B)

Вычисляет произведение Кронекера A и B и сохраняет результат в C, перезаписывая существующее содержимое C. Это выполняемая на месте версия kron.

Совместимость: Julia 1.6

Для этой функции требуется версия Julia не ниже 1.6.

 
exp(A::AbstractMatrix)

Вычисляет матричный экспоненциал A, определяемый следующим образом:

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

Примеры

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

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828
cis(A::AbstractMatrix)

Более эффективный метод для exp(im*A) квадратной матрицы A (особенно если матрица A является эрмитовой (Hermitian) или вещественно-симметричной (Symmetric)).

См. также описание cispi, sincos и exp.

Совместимость: Julia 1.7

Поддержка использования cis с матрицами была добавлена в Julia 1.7.

Примеры

julia> cis([π 0; 0 π]) ≈ -I
true
^(A::AbstractMatrix, p::Number)

Степень матрицы, эквивалент .

Примеры

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27
^(b::Number, A::AbstractMatrix)

Матричный экспоненциал, эквивалент .

Совместимость: Julia 1.1

Поддержка возведения чисел типа Irrational (например, ℯ) в степень матрицы была добавлена в Julia 1.1.

Примеры

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

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855
log(A::AbstractMatrix)

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

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

Примеры

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

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
sqrt(x)

Возвращает .

Выдает ошибку DomainError при отрицательных аргументах типа Real. Используйте вместо этого комплексные отрицательные аргументы. Обратите внимание, что sqrt имеет точку ветвления на отрицательной вещественной оси.

Префиксный оператор √ эквивалентен sqrt.

См. также описание hypot.

Примеры

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im находится ниже точки ветвления
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0
sqrt(A::AbstractMatrix)

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

Если матрица A является вещественно-симметричной или эрмитовой, для вычисления квадратного корня используется ее разложение по собственным значениям (eigen). Для таких матриц собственные значения λ, которые из-за ошибок округления кажутся слегка отрицательными, рассматриваются как нулевые. Более точно, матрицы со всеми собственными значениями ≥ -rtol*(max |λ|) рассматриваются как полуопределенные (выдающие эрмитов квадратный корень), а отрицательные собственные значения принимаются за нуль. rtol является именованным аргументом для sqrt (только для эрмитовых или вещественно-симметричных матриц), который по умолчанию имеет машинную точность, масштабированную на size(A,1).

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

Примеры

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

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0
cbrt(A::AbstractMatrix{<:Real})

Вычисляет вещественный кубический корень вещественной матрицы A. При T = cbrt(A) получается T*T*T ≈ A; см. пример ниже.

Если матрица A симметричная, т. е. имеет тип HermOrSym{<:Real}, то для нахождения кубического корня используется (eigen). В противном случае используется специальная версия алгоритма нахождения корня p-й степени [17], в которой для вычисления кубического корня применяется вещественное разложение Шура (schur).

Примеры

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true
cos(A::AbstractMatrix)

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

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

Примеры

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927
sin(A::AbstractMatrix)

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

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

Примеры

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649
sincos(A::AbstractMatrix)

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

Примеры

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

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927
tan(A::AbstractMatrix)

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

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

Примеры

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252
sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im
asin(A::AbstractMatrix)

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

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

Примеры

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im
atan(A::AbstractMatrix)

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

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

Примеры

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im
asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

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

Примеры

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

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

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

julia> A*X + X*A' ≈ -B
true
sylvester(A, B, C)

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

Примеры

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

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

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

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

julia> A*X + X*B ≈ -C
true
issuccess(F::Factorization)

Проверяет успешное разложение матрицы.

Совместимость: Julia 1.6

Для issuccess(::CholeskyPivoted) требуется версия Julia не ниже 1.6.

Примеры

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

julia> issuccess(F)
true
issuccess(F::LU; allowsingular = false)

Проверяет успешное LU-разложение матрицы. По умолчанию разложение, которое дает допустимый, но неполный по рангу множитель U, считается неудачным. Это можно изменить, передав allowsingular = true.

Совместимость: Julia 1.11

Именованный аргумент allowsingular был добавлен в Julia 1.11.

Примеры

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true
issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false
isposdef(A) -> Bool

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

См. также описание isposdef! и cholesky.

Примеры

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

julia> isposdef(A)
true
isposdef!(A) -> Bool

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

Примеры

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

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233
istril(A::AbstractMatrix, k::Integer = 0) -> Bool

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

Примеры

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

julia> istril(a)
false

julia> istril(a, 1)
true

julia> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true
istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

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

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true
isdiag(A) -> Bool

Проверяет, является ли матрица диагональной в том смысле, что iszero(A[i,j]) верно, кроме случая, когда i == j. Обратите внимание, что матрица A не обязательно должна быть квадратной; если вы хотите проверить и это, необходимо проверить соблюдение условия size(A, 1) == size(A, 2).

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false
ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true
transpose(A)

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

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

Примеры

julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # транспонирование транспонированной матрицы приводит к распаковке родительского объекта,
true

julia> Transpose(B) # однако аргумент конструктора всегда упакован
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # при изменении B автоматически изменяется A

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

Для комплексных матриц операция adjoint равносильна транспонированию сопряженной матрицы.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

Результатом операции transpose для вектора AbstractVector является вектор строк:

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

julia> transpose(v) # возвращает вектор строк
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # вычисляет точечное произведение
14

Для матрицы матриц происходит рекурсивная обработка отдельных блоков:

julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # создает блочную матрицу
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # блоки транспонируются рекурсивно
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]
transpose(F::Factorization)

Отложенное транспонирование разложения F. По умолчанию возвращает TransposeFactorization, за исключением Factorization с вещественным eltype (в этом случае возвращается AdjointFactorization).

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет ее в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память, помимо изменения размера rowval и nzval для X (если это необходимо), не выделяется.

См. описание halfperm!.

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

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

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

Примеры

julia> A = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0
TransposeFactorization
Отложенный тип оболочки для транспонирования базового объекта Factorization. Как правило, конструктор TransposeFactorization не следует вызывать напрямую. Используйте вместо этого xref:./LinearAlgebra.adoc#Base.transpose[`transpose(

Factorization)`].

A'
adjoint(A)

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

Для числовых типов функция adjoint возвращает комплексно сопряженное значение, и поэтому она эквивалентна функции тождественности для вещественных чисел.

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

Примеры

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # эквивалентное сопряжение adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # сопряжение сопряженной матрицы приводит к распаковке родительского объекта
true

julia> Adjoint(B) # однако аргумент конструктора всегда упакован
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # при изменении B автоматически изменяется A

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Для вещественных матриц операция adjoint равносильна transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

Сопряжением вектора AbstractVector является вектор строк:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # вычисляет точечное произведение, что равносильно x' * x
25 + 0im

Для матрицы матриц происходит рекурсивная обработка отдельных блоков:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]
adjoint(F::Factorization)

Отложенное сопряжение разложения F. По умолчанию возвращает оболочку AdjointFactorization.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет сопряжение элементов в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память, помимо изменения размера rowval и nzval для X (если это необходимо), не выделяется.

См. описание halfperm!.

adjoint!(dest,src)

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

Примеры

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

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

julia> adjoint!(B, A);

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

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

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

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

Примеры

julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im
AdjointFactorization
Отложенный тип оболочки для сопряжения базового объекта Factorization. Как правило, конструктор AdjointFactorization не следует вызывать напрямую. Используйте вместо этого xref:./LinearAlgebra.adoc#Base.adjoint[`adjoint(

Factorization)`].

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

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

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

Примеры

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

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im
stride1(A) -> Int

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

Примеры

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

julia> LinearAlgebra.stride1(A)
1

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

julia> LinearAlgebra.stride1(B)
2
LinearAlgebra.checksquare(A)

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

Примеры

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

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5
LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

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

Если указан именованный аргумент eltype, peakflops создает матрицы с элементами типа eltype для вычисления пиковой скорости операций с плавающей запятой.

По умолчанию peakflops использует наивысшую скорость по результатам трех попыток. Если указан именованный аргумент ntrials, peakflops определяет наивысшую скорость по результатам этого числа попыток.

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

Совместимость: Julia 1.1

Для этой функции требуется версия Julia не ниже 1.1. В Julia 1.0 она доступна в стандартной библиотеке InteractiveUtils.

 
hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Возвращает эрмитову часть квадратной матрицы A, определяемую как (A + A') / 2, в виде матрицы Hermitian. Для вещественных матриц A она также известна как симметричная часть A; иногда ее также называют «вещественная часть оператора». Необязательный аргумент uplo управляет соответствующим аргументом представления Hermitian. Для вещественных матриц последнее равносильно представлению Symmetric.

См. также описание операции hermitianpart!, выполняемой на месте.

Совместимость: Julia 1.10

Для этой функции требуется версия Julia не ниже 1.10.

 
hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Перезаписывает квадратную матрицу A на месте ее эрмитовой частью (A + A') / 2 и возвращает Hermitian(A, uplo). Для вещественных матриц A она также известна как симметричная часть A.

См. также описание соответствующей операции hermitianpart, выполняемой не на месте.

Совместимость: Julia 1.10

Для этой функции требуется версия Julia не ниже 1.10.

 
copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
              A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с присоединением следующим образом:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с транспонированием следующим образом:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Эффективно копирует элементы матрицы M в B с учетом символьного параметра tM следующим образом:

tM Место назначения Источник

B[ir_dest, jr_dest]

transpose(M)[jr_src, ir_src]

B[ir_dest, jr_dest]

M[jr_src, ir_src]

B[ir_dest, jr_dest]

conj(M)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять условиям length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

См. также описание copyto! и copy_adjoint!.

Low-level matrix operations

In many cases there are in-place versions of matrix operations that allow you to supply a pre-allocated output vector or matrix. This is useful when optimizing critical code in order to avoid the overhead of repeated allocations. These in-place operations are suffixed with ! below (e.g. mul!) according to the usual Julia convention.

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

Вычисляет произведение матрицы на матрицу или матрицы на вектор и сохраняет результат в 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);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

Реализация

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

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

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

Совместимость: Julia 1.3

Для mul! с пятью аргументами требуется версия Julia не ниже 1.3.

Примеры

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

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

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

julia> C_original = [1.0 2.0; 3.0 4.0]; # Копия исходного значения C

julia> C == A * B * α + C_original * β
true
lmul!(a::Number, B::AbstractArray)

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

Совместимость: Julia 1.1

До Julia 1.1 записи NaN и ±Inf в B обрабатывались непоследовательно.

Примеры

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

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

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

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

Примеры

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

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

julia> lmul!(A, B);

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

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

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

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0
rmul!(A::AbstractArray, b::Number)

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

Совместимость: Julia 1.1

До Julia 1.1 записи NaN и ±Inf в A обрабатывались непоследовательно.

Примеры

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

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

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

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

Примеры

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

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

julia> rmul!(A, B);

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

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

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

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0
ldiv!(Y, A, B) -> Y

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

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

Некоторые структурированные типы матриц, такие как Diagonal и UpperTriangular, допустимы, так как они уже имеют разложенную форму.

Примеры

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

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

julia> Y = zero(X);

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

julia> Y ≈ A\X
true
ldiv!(A, B)

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

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

Некоторые структурированные типы матриц, такие как Diagonal и UpperTriangular, допустимы, так как они уже имеют разложенную форму.

Примеры

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

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

julia> Y = copy(X);

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

julia> X ≈ A\Y
true
ldiv!(a::Number, B::AbstractArray)

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

Примеры

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

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0
ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

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

Совместимость: Julia 1.11

Для использования ldiv! для Tridiagonal в левой части требуется версия Julia не ниже 1.11.

 
rdiv!(A, B)

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

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

Некоторые структурированные типы матриц, такие как Diagonal и UpperTriangular, допустимы, так как они уже имеют разложенную форму.

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

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

Примеры

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

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

BLAS functions

In Julia (as in much of scientific computation), dense linear-algebra operations are based on the LAPACK library, which in turn is built on top of basic linear-algebra building-blocks known as the BLAS. There are highly optimized implementations of BLAS available for every computer architecture, and sometimes in high-performance linear algebra routines it is useful to call the BLAS functions directly.

LinearAlgebra.BLAS provides wrappers for some of the BLAS functions. Those BLAS functions that overwrite one of the input arrays have names ending in '!'. Usually, a BLAS function has four methods defined, for Float32, Float64, ComplexF32, and ComplexF64 arrays.

BLAS character arguments

Many BLAS functions accept arguments that determine whether to transpose an argument (trans), which triangle of a matrix to reference (uplo or ul), whether the diagonal of a triangular matrix can be assumed to be all ones (dA) or which side of a matrix multiplication the input argument belongs on (side). The possibilities are:

Multiplication order

side Meaning

'L'

The argument goes on the left side of a matrix-matrix operation.

'R'

The argument goes on the right side of a matrix-matrix operation.

Triangle referencing

uplo/ul Meaning

'U'

Only the upper triangle of the matrix will be used.

'L'

Only the lower triangle of the matrix will be used.

Transposition operation

trans/tX Meaning

'N'

The input matrix X is not transposed or conjugated.

'T'

The input matrix X will be transposed.

'C'

The input matrix X will be conjugated and transposed.

Unit diagonal

diag/dX Meaning

'N'

The diagonal values of the matrix X will be read.

'U'

The diagonal of the matrix X is assumed to be all ones.

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

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Задает число потоков, которые должна использовать библиотека BLAS, равным n::Integer.

Также принимает nothing. В этом случае Julia пытается угадать количество потоков по умолчанию. Передача nothing не рекомендуется и существует в основном по историческим причинам.

get_num_threads()

Получает число потоков, используемых библиотекой BLAS.

Совместимость: Julia 1.6

Для get_num_threads требуется версия Julia не ниже 1.6.

BLAS functions can be divided into three groups, also called three levels, depending on when they were first proposed, the type of input parameters, and the complexity of the operation.

Level 1 BLAS functions

The level 1 BLAS functions were first proposed in (Lawson, 1979) and define operations between scalars and vectors.

rot!(n, X, incx, Y, incy, c, s)

Перезаписывает X выражением c*X + s*Y, а Y — выражением -conj(s)*X + c*Y для первых n элементов массива X с шагом incx и первых n элементов массива Y с шагом incy. Возвращает X и Y.

Совместимость: Julia 1.5

Для rot! требуется версия Julia не ниже 1.5.

 
scal!(n, a, X, incx)
scal!(a, X)

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

Если n и incx не указаны, используются length(X) и stride(X,1).

scal(n, a, X, incx)
scal(a, X)

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

Если n и incx не указаны, используются length(X) и stride(X,1).

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

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

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

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

Примеры

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0
dotu(n, X, incx, Y, incy)

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

Примеры

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im
dotc(n, X, incx, U, incy)

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

Примеры

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

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

Примеры

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

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0
asum(n, X, incx)

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

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

Примеры

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

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0
iamax(n, dx, incx)
iamax(dx)

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

Level 2 BLAS functions

The level 2 BLAS functions were published in (Dongarra, 1988), and define matrix-vector operations.

return a vector

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

Обновляет вектор y в виде alpha*A*x + beta*y или alpha*A’x + beta*y в соответствии с операцией tA. alpha и beta являются скалярами. Возвращает обновленное значение y.

gemv(tA, alpha, A, x)

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

gemv(tA, A, x)

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

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

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

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

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

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

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

hemv(ul, alpha, A, x)

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

hemv(ul, A, x)

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

hpmv!(uplo, α, AP, x, β, y)

Обновляет вектор y в виде α*A*x + β*y, где A — это эрмитова матрица, предоставленная в упакованном формате AP.

При uplo = 'U' массив AP должен содержать верхнетреугольную часть эрмитовой матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[1, 2] и A[2, 2] и так далее.

При uplo = 'L' массив AP должен содержать нижнетреугольную часть эрмитовой матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[2, 1] и A[3, 1] и так далее.

Скалярные входные элементы α и β должны быть комплексными или вещественными числами.

Входные массивы x, y и AP должны иметь тип ComplexF32 или ComplexF64.

Возвращает обновленное значение y.

Совместимость: Julia 1.5

Для hpmv! требуется версия Julia не ниже 1.5.

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

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

symv(ul, alpha, A, x)

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

symv(ul, A, x)

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

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

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

Возвращает обновленное значение y.

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

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

sbmv(uplo, k, A, x)

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

spmv!(uplo, α, AP, x, β, y)

Обновляет вектор y в виде α*A*x + β*y, где A — это симметричная матрица, предоставленная в упакованном формате AP.

При uplo = 'U' массив AP должен содержать верхнетреугольную часть симметричной матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[1, 2] и A[2, 2] и так далее.

При uplo = 'L' массив AP должен содержать нижнетреугольную часть симметричной матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[2, 1] и A[3, 1] и так далее.

Скалярные входные элементы α и β должны быть вещественными числами.

Входные массивы x, y и AP должны иметь тип Float32 или Float64.

Возвращает обновленное значение y.

Совместимость: Julia 1.5

Для spmv! требуется версия Julia не ниже 1.5.

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

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

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

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

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

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

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

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

return a matrix

ger!(alpha, x, y, A)

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

her!(uplo, alpha, x, A)

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

syr!(uplo, alpha, x, A)

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

spr!(uplo, α, x, AP)

Обновляет матрицу A в виде A+α*x*x', где A — это симметричная матрица, предоставленная в упакованном формате AP, а x — вектор.

При uplo = 'U' массив AP должен содержать верхнетреугольную часть симметричной матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[1, 2] и A[2, 2] и так далее.

При uplo = 'L' массив AP должен содержать нижнетреугольную часть симметричной матрицы, упакованную последовательно по столбцам, так чтобы AP[1] содержало A[1, 1], AP[2] и AP[3] содержали соответственно A[2, 1] и A[3, 1] и так далее.

Скалярный входной элемент α должен быть вещественным числом.

Входные массивы x и AP должны иметь тип Float32 или Float64. Возвращает обновленное значение AP.

Совместимость: Julia 1.8

Для spr! требуется версия Julia не ниже 1.8.

Level 3 BLAS functions

The level 3 BLAS functions were published in (Dongarra, 1990), and define matrix-matrix operations.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

Обновляет нижне- или верхнетреугольную часть C, указанную в uplo, в виде alpha*A*B + beta*C или другого варианта в соответствии с tA и tB. Возвращает обновленное значение C.

Совместимость: Julia 1.11

Для gemmt! требуется версия Julia не ниже 1.11.

 
gemmt(uplo, tA, tB, alpha, A, B)

Возвращает нижне- или верхнетреугольную часть A*B, указанную в uplo, или другие три варианта в соответствии с tA и tB.

Совместимость: Julia 1.11

Для gemmt требуется версия Julia не ниже 1.11.

 
gemmt(uplo, tA, tB, A, B)

Возвращает нижне- или верхнетреугольную часть A*B, указанную в uplo, или другие три варианта в соответствии с tA и tB.

Совместимость: Julia 1.11

Для gemmt требуется версия Julia не ниже 1.11.

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

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

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

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

gemm(tA, tB, A, B)

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

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.

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

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

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

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

hemm(side, ul, A, B)

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

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

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

syrk(uplo, trans, alpha, A)

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

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

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

herk(uplo, trans, alpha, A)

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

syr2k!(uplo, trans, alpha, A, B, beta, C)

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

syr2k(uplo, trans, alpha, A, B)

Возвращает треугольник uplo для alpha*A*transpose(B) + alpha*B*transpose(A) или alpha*transpose(A)*B + alpha*transpose(B)*A в соответствии с trans.

syr2k(uplo, trans, A, B)

Возвращает треугольник uplo для A*transpose(B) + B*transpose(A) или transpose(A)*B + transpose(B)*A в соответствии с trans.

her2k!(uplo, trans, alpha, A, B, beta, C)

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

her2k(uplo, trans, alpha, A, B)

Возвращает треугольник uplo для alpha*A*B' + alpha*B*A' или alpha*A'*B + alpha*B'*A в соответствии с trans.

her2k(uplo, trans, A, B)

Возвращает треугольник uplo для A*B' + B*A' или A'*B + B'*A в соответствии с trans.

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

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

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

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

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

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

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

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

LAPACK functions

LinearAlgebra.LAPACK provides wrappers for some of the LAPACK functions for linear algebra. Those functions that overwrite one of the input arrays have names ending in '!'.

Usually a function has 4 methods defined, one each for Float64, Float32, ComplexF64 and ComplexF32 arrays.

Note that the LAPACK API provided by Julia can and will change in the future. Since this API is not user-facing, there is no commitment to support/deprecate this specific set of functions in future releases.

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

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.

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.

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

geqrf!(A, tau)

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

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

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

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

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

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

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

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

gerqf!(A, tau)

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

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

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

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

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

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.

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

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

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

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 из преобразования, предоставленного 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, transpose(A) * X = B или adjoint(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, transpose(A) * X = B или adjoint(A) * X = B для квадратной матрицы A. Изменяет матрицу или вектор B на месте с помощью решения. A является LU-разложением из getrf!, с ipiv, содержащим информацию о выборе главного элемента. trans может иметь одно из значений: N (без изменения), T (транспонирование) или C (сопряженное транспонирование).

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

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

gesvx!(A, B)

Неуравновешивающее, нетранспонирующее упрощение gesvx!.

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, вычисляются соответствующие собственные векторы.

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

Находит обобщенное разложение матриц A и B на основе собственных векторов, используя блочный алгоритм. Если jobvl = N, левые собственные векторы не вычисляются. Если jobvr = N, правые собственные векторы не вычисляются. Если jobvl = V или jobvr = V, вычисляются соответствующие собственные векторы. Для этой функции требуется LAPACK 3.6.0.

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), transpose(A) * X = B (trans = T) или adjoint(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), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентного правостороннего умножения для side = R с использованием Q из LQ-разложения матрицы A, вычисленного с помощью gelqf!. C перезаписывается.

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

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

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

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

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

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентного правостороннего умножения для side = R с использованием Q из RQ-разложения матрицы A, вычисленного с помощью gerqf!. C перезаписывается.

gemqrt!(side, trans, V, T, C)

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

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) с выбранным главным элементом для положительно определенной матрицы A с заданным пользователем допуском tol. Матрица A перезаписывается ее разложением Холецкого.

Возвращает A, главные элементы piv, ранг матрицы A и код info. Если 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)

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

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

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

trcon!(norm, uplo, diag, A)

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

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 перезаписывается ее разложением Банча-Кауфмана. ipiv содержит информацию о разложении.

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

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

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

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

Вычисляет разложение Банча-Кауфмана симметричной матрицы 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 перезаписывается ее разложением Банча-Кауфмана. ipiv содержит информацию о разложении.

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

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

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

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

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

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

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.

syevd!(jobz, uplo, A)

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

Используйте метод «разделяй и властвуй» вместо итерации QR, применяемой syev!, или нескольких относительно надежных представлений, применяемых syevr!. Сравнение точности и производительности различных методов см. в работе James W. Demmel et al, SIAM J. Sci. Comput. 30, 3, 1508 (2008).

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

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

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.

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

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

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

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

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

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

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

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

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.

hseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)

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

1. Davis, Timothy A. (2004b). Algorithm 832: UMFPACK V4.3---an Unsymmetric-Pattern Multifrontal Method. ACM Trans. Math. Softw., 30(2), 196—​199. doi:10.1145/992200.992206
2. Chen, Y., Davis, T. A., Hager, W. W., & Rajamanickam, S. (2008). Algorithm 887: CHOLMOD, Supernodal Sparse Cholesky Factorization and Update/Downdate. ACM Trans. Math. Softw., 35(3). doi:10.1145/1391989.1391995
3. Davis, Timothy A., & Hager, W. W. (2009). Dynamic Supernodes in Sparse Cholesky Update/Downdate and Triangular Solves. ACM Trans. Math. Softw., 35(4). doi:10.1145/1462173.1462176
4. 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
5. 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
6. Foster, L. V., & Davis, T. A. (2013). Algorithm 933: Reliable Calculation of Numerical Rank, Null Space Bases, Pseudoinverse Solutions, and Basic Solutions Using SuitesparseQR. ACM Trans. Math. Softw., 40(1). doi:10.1145/2513109.2513116
7. 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.
8. Issue 8859, Fix least squares, https://github.com/JuliaLang/julia/pull/8859
9. Åke Björck, Numerical Methods for Least Squares Problems, SIAM Press, Philadelphia, 1996, Other Titles in Applied Mathematics, Vol. 51. doi:10.1137/1.9781611971484
10. G. W. Stewart, Rank Degeneracy, SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. doi:10.1137/0905030
11. Konstantinos Konstantinides and Kung Yao, Statistical analysis of effective singular values in matrix rank determination, IEEE Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988, 757-763. doi:10.1109/29.1585
12. 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
13. 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
14. 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
15. Å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
16. Nicholas J. Higham, Computing real square roots of a real matrix, Linear Algebra and its Applications, 88-89, 1987, 405-430. doi:10.1016/0024-3795(87)90118-2
17. Matthew I. Smith, A Schur Algorithm for Computing Matrix pth Roots, SIAM Journal on Matrix Analysis and Applications, vol. 24, 2003, pp. 971—​989. doi:10.1137/S0895479801392697
18. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
19. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
20. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
21. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
22. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
23. Mary Aprahamian and Nicholas J. Higham, Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms, MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577