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

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

Тип Описание

Тип	Описание
`Symmetric`	Симметричная матрица
`Hermitian`	Эрмитова матрица
`UpperTriangular`	Верхняя треугольная матрица
`UnitUpperTriangular`	Верхняя треугольная матрица с единичной диагональю
`LowerTriangular`	Нижняя треугольная матрица
`UnitLowerTriangular`	Нижняя треугольная матрица с единичной диагональю
`UpperHessenberg`	Верхняя матрица Хессенберга
`Tridiagonal`	Трехдиагональная матрица
`SymTridiagonal`	Симметричная трехдиагональная матрица
`Bidiagonal`	Верхняя/нижняя бидиагональная матрица
`Diagonal`	Диагональная матрица
`UniformScaling`	Оператор равномерного масштабирования

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

UnitUpperTriangular

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

LowerTriangular

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

UnitLowerTriangular

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

UpperHessenberg

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

Tridiagonal

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

SymTridiagonal

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

Bidiagonal

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

Diagonal

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

UniformScaling

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

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

Тип матрицы + - * \ Другие функции с оптимизированными методами

Тип матрицы	`+`	`-`	`*`	`\`	Другие функции с оптимизированными методами
`Symmetric`				МВ	`inv`, `sqrt`, `exp`
`Hermitian`				МВ	`inv`, `sqrt`, `exp`
`UpperTriangular`			МВ	МВ	`inv`, `det`, `logdet`
`UnitUpperTriangular`			МВ	МВ	`inv`, `det`, `logdet`
`LowerTriangular`			МВ	МВ	`inv`, `det`, `logdet`
`UnitLowerTriangular`			МВ	МВ	`inv`, `det`, `logdet`
`UpperHessenberg`				ММ	`inv`, `det`
`SymTridiagonal`	М	М	МС	МВ	`eigmax`, `eigmin`
`Tridiagonal`	М	М	МС	МВ
`Bidiagonal`	М	М	МС	МВ
`Diagonal`	М	М	МВ	МВ	`inv`, `det`, `logdet`, `/`
`UniformScaling`	М	М	МВС	МВС	`/`

МВ

МВ

МВ

inv, det, logdet

UnitUpperTriangular

МВ

inv, det, logdet

LowerTriangular

МВ

inv, det, logdet

UnitLowerTriangular

МВ

inv, det, logdet

UpperHessenberg

ММ

inv, det

SymTridiagonal

МС

МВ

eigmax, eigmin

Tridiagonal

МС

МВ

Bidiagonal

МС

МВ

Diagonal

МВ

inv, det, logdet, /

UniformScaling

МВС

/

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

Знак	Описание
М (матрица)	Доступен оптимизированный метод для операций над двумя матрицами.
В (вектор)	Доступен оптимизированный метод для операций над матрицей и вектором.
С (скаляр)	Доступен оптимизированный метод для операций над матрицей и скаляром.

Знак

Описание

М (матрица)

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

В (вектор)

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

С (скаляр)

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

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

Тип матрицы LAPACK eigen eigvals eigvecs svd svdvals

Тип матрицы	LAPACK	`eigen`	`eigvals`	`eigvecs`	`svd`	`svdvals`
`Symmetric`	SY		ОДИ
`Hermitian`	HE		ОДИ
`UpperTriangular`	TR	Структурно	Структурно	Структурно
`UnitUpperTriangular`	TR	Структурно	Структурно	Структурно
`LowerTriangular`	TR	Структурно	Структурно	Структурно
`UnitLowerTriangular`	TR	Структурно	Структурно	Структурно
`SymTridiagonal`	ST	Структурно	ОДИ	ОВ
`Tridiagonal`	GT
`Bidiagonal`	BD				Структурно	Структурно
`Diagonal`	DI		Структурно

Symmetric

ОДИ

Hermitian

ОДИ

UpperTriangular

Структурно

UnitUpperTriangular

Структурно

LowerTriangular

Структурно

UnitLowerTriangular

Структурно

SymTridiagonal

Структурно

ОДИ

ОВ

Tridiagonal

Bidiagonal

Структурно

Diagonal

Структурно

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

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

Знак	Описание	Пример
О (общий)	Доступен оптимизированный метод для нахождения всех собственных значений или векторов.	например `eigvals(M)`
Д (диапазон)	Доступен оптимизированный метод для нахождения собственных значений в диапазоне с `il` по `ih`.	`eigvals(M, il, ih)`
И (интервал)	Доступен оптимизированный метод для нахождения собственных значений в интервале [`vl`, `vh`].	`eigvals(M, vl, vh)`
В (векторы)	Доступен оптимизированный метод для нахождения собственных векторов, соответствующих собственным значениям `x=[x1, x2,...]`.	`eigvecs(M, x)`

О (общий)

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

например 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`	Обобщенное разложение Шура

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

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

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

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

# Base.:* — Method

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

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

Примеры

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

# Base.:\ — Method

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

# Base.:/ — Method

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

# LinearAlgebra.SingularException — Type

SingularException

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

# LinearAlgebra.PosDefException — Type

PosDefException

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

# LinearAlgebra.ZeroPivotException — Type

ZeroPivotException <: Exception

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

# LinearAlgebra.dot — Function

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

# LinearAlgebra.dot — Method

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

# LinearAlgebra.cross — Function

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

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

Примеры

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

# LinearAlgebra.axpy! — Function

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

# LinearAlgebra.axpby! — Function

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

# LinearAlgebra.rotate! — Function

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.

# LinearAlgebra.reflect! — Function

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.

# LinearAlgebra.factorize — Function

factorize(A)

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

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

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

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

Разложение Холецкого (см. 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.

# LinearAlgebra.Diagonal — Type

Diagonal(V::AbstractVector)

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

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

Примеры

julia> 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

Diagonal(A::AbstractMatrix)

Создает матрицу из диагонали матрицы A.

Примеры

julia> A = permutedims(reshape(1:15, 5, 3))
3×5 Matrix{Int64}:
  1   2   3   4   5
  6   7   8   9  10
 11  12  13  14  15

julia> Diagonal(A)
3×3 Diagonal{Int64, Vector{Int64}}:
 1  ⋅   ⋅
 ⋅  7   ⋅
 ⋅  ⋅  13

julia> diag(A, 2)
3-element Vector{Int64}:
  3
  9
 15

Diagonal{T}(undef, n)

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

# LinearAlgebra.Bidiagonal — Type

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

# LinearAlgebra.SymTridiagonal — Type

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]

# LinearAlgebra.Tridiagonal — Type

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

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

Примеры

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

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

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

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, 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

# LinearAlgebra.Symmetric — Type

Symmetric(A, uplo=:U)

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

Примеры

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

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

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

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

# LinearAlgebra.Hermitian — Type

Hermitian(A, uplo=:U)

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

Примеры

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

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

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

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

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

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

# LinearAlgebra.LowerTriangular — Type

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

# LinearAlgebra.UpperTriangular — Type

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

# LinearAlgebra.UnitLowerTriangular — Type

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

# LinearAlgebra.UnitUpperTriangular — Type

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

# LinearAlgebra.UpperHessenberg — Type

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

# LinearAlgebra.UniformScaling — Type

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

# LinearAlgebra.I — Constant

Объект типа 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

# LinearAlgebra.UniformScaling — Method

(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 — Type

LinearAlgebra.Factorization

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

# LinearAlgebra.LU — Type

LU <: Factorization

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

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

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

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

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

# LinearAlgebra.lu — Function

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 по умолчанию соответствует конфигурациям пакета по умолчанию для UMFPACK, но его можно изменить, передав вектор длины UMFPACK_CONTROL. Возможные конфигурации см. в руководстве по UMFPACK. Имена соответствующих переменных начинаются с JL_UMFPACK_, так как в Julia применяется индексирование с отсчетом от единицы.

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

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

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

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 также поддерживает следующие функции.

\
det

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

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

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

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

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

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

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

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

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

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

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}}

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

✓

✓

✓

✓

✓

✓

✓

Примеры

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

# LinearAlgebra.lu! — Function

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 имеют разный размер, размер всех векторов изменится соответствующим образом.

См. также описание 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) -> LU

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

Примеры

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

# LinearAlgebra.Cholesky — Type

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

# LinearAlgebra.CholeskyPivoted — Type

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

# LinearAlgebra.cholesky — Function

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

Примеры

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

Примеры

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, но также методы diag, det и logdet определены для F. Вы также можете извлекать отдельные множители из F с помощью F.L. Однако поскольку выбор главного элемента включен по умолчанию, разложение представлено как A == P'*L*L'*P с матрицей перестановки P. При использовании только L без учета P будут выдаваться неправильные ответы. Чтобы включить эффекты перестановки, обычно предпочтительнее извлекать «комбинированные» множители, такие как PtL = F.PtL (эквивалент P'*L) и LtP = F.UP (эквивалент L'*P).

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

Примеры

В следующем примере используется сокращающая заполнение перестановка [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}
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}
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 поддерживает только числа типа double или комплексные числа с элементами типа double. Входные матрицы, не относящиеся к этим типам элементов, будут преобразованы в SparseMatrixCSC{Float64} или SparseMatrixCSC{ComplexF64} в зависимости от ситуации. Многие другие функции из CHOLMOD инкапсулированы, но не экспортированы из модуля Base.SparseArrays.CHOLMOD.

# LinearAlgebra.cholesky! — Function

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

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

Примеры

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!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

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

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

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

# LinearAlgebra.lowrankupdate — Function

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

# LinearAlgebra.lowrankdowndate — Function

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

# LinearAlgebra.lowrankupdate! — Function

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 уничтожается.

# LinearAlgebra.lowrankdowndate! — Function

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 уничтожается.

# LinearAlgebra.LDLt — Type

LDLt <: Factorization

Тип разложения матрицы для LDLt-разложения вещественной матрицы SymTridiagonal. S, так что 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`

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

# LinearAlgebra.ldlt — Function

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.

# LinearAlgebra.ldlt! — Function

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.

# LinearAlgebra.QR — Type

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), содержащий коэффициенты .

# LinearAlgebra.QRCompactWY — Type

QRCompactWY <: Factorization

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

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

так что является -м столбцом матрицы , является -м элементом [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].

# LinearAlgebra.QRPivoted — Type

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, соответствующим перестановке .

# LinearAlgebra.qr — Function

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)

При итерации декомпозиции создаются компоненты 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. Если 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}}:
 -0.6   0.0   0.8
 -0.8   0.0  -0.6
  0.0  -1.0   0.0
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 могут храниться в компактом виде, а не как две отдельные плотные матрицы.

# LinearAlgebra.qr! — Function

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

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

Совместимость: 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}}:
 -0.316228  -0.948683
 -0.948683   0.316228
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:
[...]

# LinearAlgebra.LQ — Type

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}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

# LinearAlgebra.lq — Function

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}}:
 -0.581238  -0.813733
 -0.813733   0.581238

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

# LinearAlgebra.lq! — Function

lq!(A) -> LQ

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

# LinearAlgebra.BunchKaufman — Type

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 = [1 2; 2 3]
2×2 Matrix{Int64}:
 1  2
 2  3

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

# LinearAlgebra.bunchkaufman — Function

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

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

Примеры

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

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

# LinearAlgebra.bunchkaufman! — Function

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

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

# LinearAlgebra.Eigen — Type

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

# LinearAlgebra.GeneralizedEigen — Type

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

# LinearAlgebra.eigvals — Function

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

# LinearAlgebra.eigvals! — Function

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 — это верхняя граница.

# LinearAlgebra.eigmax — Function

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

# LinearAlgebra.eigmin — Function

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

# LinearAlgebra.eigvecs — Function

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

# LinearAlgebra.eigen — Function

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

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

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

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

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

По умолчанию собственные значения и векторы сортируются лексикографически по (real(λ),imag(λ)). В 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. (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);

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

При итерации декомпозиции создаются компоненты 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

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

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

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

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

# LinearAlgebra.eigen! — Function

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

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

# LinearAlgebra.Hessenberg — Type

Hessenberg <: Factorization

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

# LinearAlgebra.hessenberg — Function

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}:
 1.0   0.0        0.0
 0.0  -0.707107  -0.707107
 0.0  -0.707107   0.707107
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

# LinearAlgebra.hessenberg! — Function

hessenberg!(A) -> Hessenberg

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

# LinearAlgebra.Schur — Type

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

# LinearAlgebra.GeneralizedSchur — Type

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

# LinearAlgebra.schur — Function

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

# LinearAlgebra.schur! — Function

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 в качестве рабочей области.

# LinearAlgebra.ordschur — Function

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

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

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

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

# LinearAlgebra.ordschur! — Function

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

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

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

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

# LinearAlgebra.SVD — Type

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

# LinearAlgebra.GeneralizedSVD — Type

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

# LinearAlgebra.svd — Function

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 в полном разложении U является , а V является , тогда как в тонком разложении U является , а 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

# LinearAlgebra.svd! — Function

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.

# LinearAlgebra.svdvals — Function

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

# LinearAlgebra.svdvals! — Function

svdvals!(A)

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

svdvals!(A, B)

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

# LinearAlgebra.Givens — Type

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

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

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

# LinearAlgebra.givens — Function

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

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

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

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

y = G*x

имеет свойство, когда

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

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

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

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

B = G*A

имеет свойство, когда

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

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

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

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

B = G*x

имеет свойство, когда

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

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

# LinearAlgebra.triu — Function

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

# LinearAlgebra.triu! — Function

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

# LinearAlgebra.tril — Function

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

# LinearAlgebra.tril! — Function

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

# LinearAlgebra.diagind — Function

diagind(M, k::Integer=0)

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

См. также описание 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

# LinearAlgebra.diag — Function

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

# LinearAlgebra.diagm — Function

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

# LinearAlgebra.rank — Function

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)

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

Совместимость: 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

# LinearAlgebra.norm — Function

norm(A, p::Real=2)

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

p-норма определяется следующим образом:

где — элементы , — норма (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)

Для чисел возвращается .

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

# LinearAlgebra.opnorm — Function

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)

Для чисел возвращается . Это эквивалентно norm.

opnorm(A::Adjoint{<:Any,<:AbstracVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstracVector}, 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

# LinearAlgebra.normalize! — Function

normalize!(a::AbstractArray, p::Real=2)

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

# LinearAlgebra.normalize — Function

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

# LinearAlgebra.cond — Function

cond(M, p::Real=2)

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

# LinearAlgebra.condskeel — Function

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

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

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

# LinearAlgebra.tr — Function

tr(M)

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

Примеры

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

julia> tr(A)
5

# LinearAlgebra.det — Function

det(M)

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

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

Примеры

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

julia> det(M)
2.0

# LinearAlgebra.logdet — Function

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

# LinearAlgebra.logabsdet — Function

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)

# Base.inv — Method

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

# LinearAlgebra.pinv — Function

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # будет устаревшим (нерекомендуемым) в 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

# LinearAlgebra.nullspace — Function

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # будет устаревшим (нерекомендуемым) в 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

# Base.kron — Function

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

# Base.kron! — Function

kron!(C, A, B)

Вычисляет произведение Кронекера A и B и сохраняет результат в C, перезаписывая существующее содержимое C. Это выполняемая на месте версия kron.

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

Для этой функции требуется версия не ниже Julia 1.6.

s76"} where var"#s76"<:Union{Float32, Float64, ComplexF64, ComplexF32}}"> Base.exp — Method

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

# Base.cis — Method

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

# Base.:^ — Method

^(A::AbstractMatrix, p::Number)

Степень матрицы, эквивалент

Примеры

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

# Base.:^ — Method

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

# Base.log — Method

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

# Base.sqrt — Method

sqrt(x)

Возвращает . Выдает ошибку DomainError при отрицательных аргументах типа Real. Используйте вместо этого комплексные отрицательные аргументы. Префиксный оператор √ эквивалентен 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> .√(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

s76"} where var"#s76"<:Real}"> Base.cos — Method

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

s76"} where var"#s76"<:Real}"> Base.sin — Method

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

s76"} where var"#s76"<:Real}"> Base.Math.sincos — Method

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

s76"} where var"#s76"<:Real}"> Base.tan — Method

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

# Base.Math.sec — Method

sec(A::AbstractMatrix)

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

# Base.Math.csc — Method

csc(A::AbstractMatrix)

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

# Base.Math.cot — Method

cot(A::AbstractMatrix)

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

# Base.cosh — Method

cosh(A::AbstractMatrix)

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

# Base.sinh — Method

sinh(A::AbstractMatrix)

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

# Base.tanh — Method

tanh(A::AbstractMatrix)

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

# Base.Math.sech — Method

sech(A::AbstractMatrix)

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

# Base.Math.csch — Method

csch(A::AbstractMatrix)

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

# Base.Math.coth — Method

coth(A::AbstractMatrix)

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

# Base.acos — Method

acos(A::AbstractMatrix)

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

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

Примеры

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

# Base.asin — Method

asin(A::AbstractMatrix)

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

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

Примеры

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

# Base.atan — Method

atan(A::AbstractMatrix)

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

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

Примеры

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

# Base.Math.asec — Method

asec(A::AbstractMatrix)

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

# Base.Math.acsc — Method

acsc(A::AbstractMatrix)

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

# Base.Math.acot — Method

acot(A::AbstractMatrix)

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

# Base.acosh — Method

acosh(A::AbstractMatrix)

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

# Base.asinh — Method

asinh(A::AbstractMatrix)

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

# Base.atanh — Method

atanh(A::AbstractMatrix)

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

# Base.Math.asech — Method

asech(A::AbstractMatrix)

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

# Base.Math.acsch — Method

acsch(A::AbstractMatrix)

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

# Base.Math.acoth — Method

acoth(A::AbstractMatrix)

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

# LinearAlgebra.lyap — Function

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

# LinearAlgebra.sylvester — Function

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

# LinearAlgebra.issuccess — Function

issuccess(F::Factorization)

Проверяет успешное разложение матрицы.

!!! compat "Julia 1.6"

Для issuccess(::CholeskyPivoted) требуется версия не ниже Julia 1.6.

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

julia> issuccess(F)
true

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

julia> issuccess(F)
false

# LinearAlgebra.issymmetric — Function

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

# LinearAlgebra.isposdef — Function

isposdef(A) -> Bool

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

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

Примеры

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

julia> isposdef(A)
true

# LinearAlgebra.isposdef! — Function

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

# LinearAlgebra.istril — Function

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> b = [1 0; -im -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+0im
 0-1im  -1+0im

julia> istril(b)
true

julia> istril(b, -1)
false

# LinearAlgebra.istriu — Function

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> b = [1 im; 0 -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+1im
 0+0im  -1+0im

julia> istriu(b)
true

julia> istriu(b, 1)
false

# LinearAlgebra.isdiag — Function

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

# LinearAlgebra.ishermitian — Function

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

# Base.transpose — Function

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]

# LinearAlgebra.transpose! — Function

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!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет ее в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память, помимо изменения размера rowval и nzval для X (если это необходимо), не выделяется.

Дополнительные сведения см. в описании halfperm!.

# LinearAlgebra.Transpose — Type

Transpose

Отложенный тип оболочки для транспонирующего представления базового объекта линейной алгебры, обычно AbstractVector/AbstractMatrix, а также некоторого Factorization, к примеру. Как правило, конструктор 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

# Base.adjoint — Function

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]

# LinearAlgebra.adjoint! — Function

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!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Транспонирует матрицу A и сохраняет сопряжение элементов в матрице X. size(X) должно быть равно size(transpose(A)). Дополнительная память, помимо изменения размера rowval и nzval для X (если это необходимо), не выделяется.

Дополнительные сведения см. в описании halfperm!.

# LinearAlgebra.Adjoint — Type

Adjoint

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

Примеры

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

# Base.copy — Method

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

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

Примеры

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

# LinearAlgebra.stride1 — Function

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 — Function

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 — Function

LinearAlgebra.peakflops(n::Integer=2000; parallel::Bool=false)

Функция peakflops вычисляет пиковую скорость операций с плавающей запятой компьютера с помощью функции gemm! двойной точности. По умолчанию, если аргументы не указаны, она умножает матрицу размера n x n, где n = 2000. Если базовая подпрограмма BLAS использует несколько потоков, реализуются более высокие скорости операций с плавающей запятой. Число потоков BLAS можно задать с помощью функции BLAS.set_num_threads(n).

Если именованный аргумент parallel имеет значение true, функция выполняется peakflops параллельно во всех рабочих процессах. Возвращается скорость операций с плавающей запятой всего параллельного компьютера. Когда при параллельном выполнении используется только один поток BLAS. Аргумент n по-прежнему относится к размеру задачи, которая решается в каждом процессоре.

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

Для этой функции требуется версия Julia не ниже 1.1. В Julia 1.0 она доступна в стандартной библиотеке InteractiveUtils.

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

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

# LinearAlgebra.mul! — Function

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); mul!(Y, A, B);

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

Реализация

Для пользовательских матричных и векторных типов рекомендуется реализовать 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> mul!(C, A, B, 100.0, 10.0) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

# LinearAlgebra.lmul! — Function

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

# LinearAlgebra.rmul! — Function

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

# LinearAlgebra.ldiv! — Function

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
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\X
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(A, B)

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

Примеры

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

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

julia> Y = copy(X);

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

julia> X
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

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

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

Примеры

julia> B = [1.0 2.0; 3.0 4.0]
2×2 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

# LinearAlgebra.rdiv! — Function

rdiv!(A, B)

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

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

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

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

Примеры

julia> A = [1.0 2.0; 3.0 4.0]
2×2 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

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

В LinearAlgebra.BLAS доступны оболочки для некоторых BLAS-функций. Эти функции BLAS перезаписывают один из входных массивов, и их имена заканчиваются на '!'. Как правило, для функции BLAS определено четыре метода: для массивов Float32, Float64, ComplexF32 и ComplexF64.

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

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

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

side Значение

`side`	Значение
`'L'`	Аргумент в операции с двумя матрицами относится к левой стороне.
`'R'`	Аргумент в операции с двумя матрицами относится к правой стороне.

'L'

Аргумент в операции с двумя матрицами относится к левой стороне.

'R'

Аргумент в операции с двумя матрицами относится к правой стороне.

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

uplo/ul Значение

`uplo`/`ul`	Значение
`'U'`	Будет использоваться только верхний треугольник матрицы.
`'L'`	Будет использоваться только нижний треугольник матрицы.

'U'

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

'L'

Будет использоваться только нижний треугольник матрицы.

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

trans/tX Значение

`trans`/`tX`	Значение
`'N'`	Входная матрица `X` не транспонируется и не сопрягается.
`'T'`	Входная матрица `X` транспонируется.
`'C'`	Входная матрица `X` транспонируется и сопрягается.

'N'

Входная матрица X не транспонируется и не сопрягается.

'T'

Входная матрица X транспонируется.

'C'

Входная матрица X транспонируется и сопрягается.

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

diag/dX Значение

`diag`/`dX`	Значение
`'N'`	Диагональные значения матрицы `X` будут считываться.
`'U'`	Все диагональные значения матрицы `X` принимаются за единицы.

'N'

Диагональные значения матрицы X будут считываться.

'U'

Все диагональные значения матрицы X принимаются за единицы.

# LinearAlgebra.BLAS — Module

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

# LinearAlgebra.BLAS.set_num_threads — Function

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Задает число потоков, которые должна использовать библиотека BLAS, равным n::Integer.

Также принимает nothing. В этом случае Julia пытается угадать количество потоков по умолчанию. Передача nothing не рекомендуется и существует в основном по историческим причинам.

# LinearAlgebra.BLAS.get_num_threads — Function

get_num_threads()

Получает число потоков, используемых библиотекой BLAS.

!!! compat "Julia 1.6"

Для get_num_threads требуется версия не ниже Julia 1.6.

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

Функции BLAS уровня 1

Функции BLAS уровня 1 были впервые предложены в работе Лоусона (Lawson) 1979 года и определяют операции между скалярными величинами и векторами.

# LinearAlgebra.BLAS.rot! — Function

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.

# LinearAlgebra.BLAS.scal! — Function

scal!(n, a, X, incx)
scal!(a, X)

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

Если n и incx не указаны, используются length(X) и stride(X,1).

# LinearAlgebra.BLAS.scal — Function

scal(n, a, X, incx)
scal(a, X)

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

Если n и incx не указаны, используются length(X) и stride(X,1).

# LinearAlgebra.BLAS.blascopy! — Function

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

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

# LinearAlgebra.BLAS.dot — Function

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

# LinearAlgebra.BLAS.dotu — Function

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

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

Примеры

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

# LinearAlgebra.BLAS.dotc — Function

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

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

Примеры

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

# LinearAlgebra.BLAS.nrm2 — Function

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

# LinearAlgebra.BLAS.asum — Function

asum(n, X, incx)

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

Для вещественного массива величина является абсолютным значением. Для комплексного массива величина представляет собой сумму абсолютного значения вещественной части и абсолютного значения мнимой части.

Примеры

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

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

# LinearAlgebra.BLAS.iamax — Function

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

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

Функции BLAS уровня 2

Функции BLAS уровня 2 были впервые предложены в [работе Донгарры (Dongarra) 1988 года][Донгарра (Dongarra), 1988 г.] и определяют матрично-векторные операции.

возвращает вектор

# LinearAlgebra.BLAS.gemv! — Function

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

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

# LinearAlgebra.BLAS.gemv — Method

gemv(tA, alpha, A, x)

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

# LinearAlgebra.BLAS.gemv — Method

gemv(tA, A, x)

Возвращает A*x или A’x в соответствии с операцией tA.

# LinearAlgebra.BLAS.gbmv! — Function

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

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

# LinearAlgebra.BLAS.gbmv — Function

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

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

# LinearAlgebra.BLAS.hemv! — Function

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

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

# LinearAlgebra.BLAS.hemv — Method

hemv(ul, alpha, A, x)

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

# LinearAlgebra.BLAS.hemv — Method

hemv(ul, A, x)

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

# LinearAlgebra.BLAS.hpmv! — Function

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.

# LinearAlgebra.BLAS.symv! — Function

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

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

# LinearAlgebra.BLAS.symv — Method

symv(ul, alpha, A, x)

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

# LinearAlgebra.BLAS.symv — Method

symv(ul, A, x)

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

# LinearAlgebra.BLAS.sbmv! — Function

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

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

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

# LinearAlgebra.BLAS.sbmv — Method

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

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

# LinearAlgebra.BLAS.sbmv — Method

sbmv(uplo, k, A, x)

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

# LinearAlgebra.BLAS.spmv! — Function

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.

# LinearAlgebra.BLAS.trmv! — Function

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

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

# LinearAlgebra.BLAS.trmv — Function

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

# LinearAlgebra.BLAS.trsv! — Function

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

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

# LinearAlgebra.BLAS.trsv — Function

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

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

возвращает матрицу

# LinearAlgebra.BLAS.ger! — Function

ger!(alpha, x, y, A)

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

# LinearAlgebra.BLAS.her! — Function

her!(uplo, alpha, x, A)

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

# LinearAlgebra.BLAS.syr! — Function

syr!(uplo, alpha, x, A)

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

# LinearAlgebra.BLAS.spr! — Function

spr!(uplo, α, x, AP)

Обновляет матрицу A в виде A+α*x*x', где A — это симметричная матрица, предоставленная в упакованном формате AP, а x — вектор.

Скалярный входной элемент α должен быть вещественным числом.

Входные массивы x и AP должны иметь тип Float32 или Float64. Возвращает обновленный вектор AP.

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

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

Функции BLAS уровня 3

Функции BLAS уровня 3 были впервые предложены в [работе Донгарры (Dongarra) 1990 года][Донгарра (Dongarra), 1990 г.] и определяют матрично-матричные операции.

# LinearAlgebra.BLAS.gemm! — Function

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

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

# LinearAlgebra.BLAS.gemm — Method

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

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

# LinearAlgebra.BLAS.gemm — Method

gemm(tA, tB, A, B)

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

# LinearAlgebra.BLAS.symm! — Function

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

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

# LinearAlgebra.BLAS.symm — Method

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

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

# LinearAlgebra.BLAS.symm — Method

symm(side, ul, A, B)

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

# LinearAlgebra.BLAS.hemm! — Function

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

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

# LinearAlgebra.BLAS.hemm — Method

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

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

# LinearAlgebra.BLAS.hemm — Method

hemm(side, ul, A, B)

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

# LinearAlgebra.BLAS.syrk! — Function

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.

# LinearAlgebra.BLAS.syrk — Function

syrk(uplo, trans, alpha, A)

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

# LinearAlgebra.BLAS.herk! — Function

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

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

# LinearAlgebra.BLAS.herk — Function

herk(uplo, trans, alpha, A)

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

# LinearAlgebra.BLAS.syr2k! — Function

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.

# LinearAlgebra.BLAS.syr2k — Function

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.

# LinearAlgebra.BLAS.her2k! — Function

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.

# LinearAlgebra.BLAS.her2k — Function

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.

# LinearAlgebra.BLAS.trmm! — Function

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

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

# LinearAlgebra.BLAS.trmm — Function

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

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

# LinearAlgebra.BLAS.trsm! — Function

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

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

# LinearAlgebra.BLAS.trsm — Function

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

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

Функции LAPACK

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

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

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

# LinearAlgebra.LAPACK — Module

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

# LinearAlgebra.LAPACK.gbtrf! — Function

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

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

# LinearAlgebra.LAPACK.gbtrs! — Function

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

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

# LinearAlgebra.LAPACK.gebal! — Function

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

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

# LinearAlgebra.LAPACK.gebak! — Function

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

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

# LinearAlgebra.LAPACK.gebrd! — Function

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

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

# LinearAlgebra.LAPACK.gelqf! — Function

gelqf!(A, tau)

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

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

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

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

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

# LinearAlgebra.LAPACK.geqlf! — Function

geqlf!(A, tau)

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

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

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

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

# LinearAlgebra.LAPACK.geqrf! — Function

geqrf!(A, tau)

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

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

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

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

# LinearAlgebra.LAPACK.geqp3! — Function

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.

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

# LinearAlgebra.LAPACK.gerqf! — Function

gerqf!(A, tau)

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

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

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

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

# LinearAlgebra.LAPACK.geqrt! — Function

geqrt!(A, T)

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

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

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

Вычисляет блочное QR-разложение A, A = QR. nb задает размер блока, и его значение должно быть в диапазоне от 1 до n, второе измерение A.

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

# LinearAlgebra.LAPACK.geqrt3! — Function

geqrt3!(A, T)

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

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

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

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

# LinearAlgebra.LAPACK.getrf! — Function

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

Вычисляет LU-разложение матрицы A с выбранным главным элементом, A = LU.

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

# LinearAlgebra.LAPACK.tzrzf! — Function

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

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

# LinearAlgebra.LAPACK.ormrz! — Function

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, измененную на месте, с результатом умножения.

# LinearAlgebra.LAPACK.gels! — Function

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

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

# LinearAlgebra.LAPACK.gesv! — Function

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

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

# LinearAlgebra.LAPACK.getrs! — Function

getrs!(trans, A, ipiv, B)

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

# LinearAlgebra.LAPACK.getri! — Function

getri!(A, ipiv)

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

# LinearAlgebra.LAPACK.gesvx! — Function

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

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

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

gesvx!(A, B)

Неуравновешивающее, нетранспонирующее упрощение gesvx!.

# LinearAlgebra.LAPACK.gelsd! — Function

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

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

# LinearAlgebra.LAPACK.gelsy! — Function

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

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

# LinearAlgebra.LAPACK.gglse! — Function

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

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

# LinearAlgebra.LAPACK.geev! — Function

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

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

# LinearAlgebra.LAPACK.gesdd! — Function

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

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

# LinearAlgebra.LAPACK.gesvd! — Function

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

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

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

# LinearAlgebra.LAPACK.ggsvd! — Function

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

Находит обобщенное разложение сингулярного значения матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. На диагонали D1 находится alpha, а на диагонали D2 — beta. Если jobu = U, вычисляется ортогональная или унитарная матрица U. При jobv = V, вычисляется ортогональная или унитарная матрица V. Если jobq = Q, вычисляется ортогональная или унитарная матрица Q. Если jobu, jobv или jobq имеет значение N, эта матрица не вычисляется. Эта функция доступна только в версиях LAPACK, предшествующих 3.6.0.

# LinearAlgebra.LAPACK.ggsvd3! — Function

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

Находит обобщенное разложение сингулярного значения матриц A и B, U'*A*Q = D1*R и V'*B*Q = D2*R. На диагонали D1 находится alpha, а на диагонали D2 — beta. Если jobu = U, вычисляется ортогональная или унитарная матрица U. При jobv = V, вычисляется ортогональная или унитарная матрица V. Если jobq = Q, вычисляется ортогональная или унитарная матрица Q. Если jobu, jobv или jobq имеет значение N, эта матрица не вычисляется. Для этой функции требуется LAPACK 3.6.0.

# LinearAlgebra.LAPACK.geevx! — Function

geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)

Находит собственную систему матрицы A с балансировкой матрицы. Если jobvl = N, левые собственные векторы матрицы A не вычисляются. Если jobvr = N, правые собственные векторы матрицы A не вычисляются. Если jobvl = V или jobvr = V, вычисляются соответствующие собственные векторы. Если balanc = N, балансировка не выполняется. Если balanc = P, матрица A переставляется, но не масштабируется. Если balanc = S, матрица A масштабируется, но не переставляется. Если balanc = B, матрица A переставляется и масштабируется. Если sense = N, взаимно обратные числа обусловленности не вычисляются. Если sense = E, взаимно обратные числа обусловленности вычисляются только для собственных значений. Если sense = V, взаимно обратные числа обусловленности вычисляются только для правых собственных векторов. Если sense = B, взаимно обратные числа обусловленности вычисляются только для правых собственных векторов и собственных векторов. Если sense = E,B, должны быть вычислены правые и левые собственные векторы.

# LinearAlgebra.LAPACK.ggev! — Function

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

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

# LinearAlgebra.LAPACK.gtsv! — Function

gtsv!(dl, d, du, B)

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

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

# LinearAlgebra.LAPACK.gttrf! — Function

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

Находит LU-разложение трехдиагональной матрицы с dl на поддиагонали, d на диагонали и du на наддиагонали.

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

# LinearAlgebra.LAPACK.gttrs! — Function

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

Решает уравнение A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) с использованием LU-разложения, вычисленного с помощью gttrf!. B перезаписывается решением X.

# LinearAlgebra.LAPACK.orglq! — Function

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

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

# LinearAlgebra.LAPACK.orgqr! — Function

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

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

# LinearAlgebra.LAPACK.orgql! — Function

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

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

# LinearAlgebra.LAPACK.orgrq! — Function

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

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

# LinearAlgebra.LAPACK.ormlq! — Function

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

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

# LinearAlgebra.LAPACK.ormqr! — Function

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

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

# LinearAlgebra.LAPACK.ormql! — Function

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

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

# LinearAlgebra.LAPACK.ormrq! — Function

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

Вычисляет Q * C (trans = N), transpose(Q) * C (trans = T), adjoint(Q) * C (trans = C) для side = L или эквивалентного правостороннего умножения для side = R с использованием Q из RQ-разложения матрицы A, вычисленного с помощью gerqf!. C перезаписывается.

# LinearAlgebra.LAPACK.gemqrt! — Function

gemqrt!(side, trans, V, T, C)

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

# LinearAlgebra.LAPACK.posv! — Function

posv!(uplo, A, B) -> (A, B)

Находит решение для A * X = B, где A является симметричной или эрмитовой положительной определенной матрицей. Если uplo = U, вычисляется разложение Холецкого матрицы A. Если uplo = L, вычисляется нижнее разложение Холецкого матрицы A . Матрица A перезаписывается ее разложением Холецкого. B перезаписывается решением X.

# LinearAlgebra.LAPACK.potrf! — Function

potrf!(uplo, A)

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

# LinearAlgebra.LAPACK.potri! — Function

potri!(uplo, A)

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

Матрица A перезаписывается своим обратным эквивалентом и возвращается.

# LinearAlgebra.LAPACK.potrs! — Function

potrs!(uplo, A, B)

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

# LinearAlgebra.LAPACK.pstrf! — Function

pstrf!(uplo, A, tol) -> (A, piv, rank, info)

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

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

# LinearAlgebra.LAPACK.ptsv! — Function

ptsv!(D, E, B)

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

# LinearAlgebra.LAPACK.pttrf! — Function

pttrf!(D, E)

Вычисляет LDLt-разложение положительно определенной треугольной матрицы с D в качестве диагонали и E в качестве внедиагонали. D и E перезаписываются и возвращаются.

# LinearAlgebra.LAPACK.pttrs! — Function

pttrs!(D, E, B)

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

# LinearAlgebra.LAPACK.trtri! — Function

trtri!(uplo, diag, A)

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

# LinearAlgebra.LAPACK.trtrs! — Function

trtrs!(uplo, trans, diag, A, B)

Решает A * X = B (trans = N), transpose(A) * X = B (trans = T) или adjoint(A) * X = B (trans = C) для (верхней, если uplo = U, нижней, если uplo = L) треугольной матрицы A. Если diag = N, матрица A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы матрицы A равны единице. B перезаписывается решением X.

# LinearAlgebra.LAPACK.trcon! — Function

trcon!(norm, uplo, diag, A)

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

# LinearAlgebra.LAPACK.trevc! — Function

trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))

Находит собственную систему верхней треугольной матрицы T. Если side = R, вычисляются собственные векторы. Если side = L, вычисляются левые собственные векторы. Если side = B, вычисляются оба набора. Если howmny = A, будут найдены все собственные векторы. Если howmny = B, будут найдены все собственные векторы, и они и будут обратно преобразованы с помощью VL и VR. Если howmny = S, вычисляются только собственные векторы, соответствующие значениям в select.

# LinearAlgebra.LAPACK.trrfs! — Function

trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)

Оценивает погрешность в решении для A * X = B (trans = N), transpose(A) * X = B (trans = T), adjoint(A) * X = B (trans = C) для side = L, или эквивалентных уравнений правосторонней side = R X * A после вычисления X с помощью trtrs!. Если uplo = U, матрица A является верхним треугольником. Если uplo = L, матрица A является нижним треугольником. Если diag = N, матрица A имеет неединичные диагональные элементы. Если diag = U, все диагональные элементы матрицы A равны единице. Ferr и Berr являются дополнительными входными данными. Ferr — это прямая погрешность, а Berr — это обратная погрешность, каждая является покомпонентной.

# LinearAlgebra.LAPACK.stev! — Function

stev!(job, dv, ev) -> (dv, Zmat)

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

# LinearAlgebra.LAPACK.stebz! — Function

stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)

Вычисляет собственные значения для симметричной трехдиагональной матрицы с dv как диагональным и ev как внедиагональным. Если range = A, будут найдены все собственные значения. Если range = V, будут найдены собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, будут найдены собственные значения с индексами между il и iu. Если order = B, собственные значения упорядочиваются в рамках блока. Если order = E, они упорядочиваются во всех блоках. abstol можно задать как допуск на сходимость.

# LinearAlgebra.LAPACK.stegr! — Function

stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)

Вычисляет собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) для симметричной трехдиагональной матрицы с dv как диагональным и ev как внедиагональным. Если range = A, будут найдены все собственные значения. Если range = V, будут найдены собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, будут найдены собственные значения с индексами между il и iu. Собственные значения возвращаются в w, а собственные векторы — в Z.

# LinearAlgebra.LAPACK.stein! — Function

stein!(dv, ev_in, w_in, iblock_in, isplit_in)

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

# LinearAlgebra.LAPACK.syconv! — Function

syconv!(uplo, A, ipiv) -> (A, work)

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

# LinearAlgebra.LAPACK.sysv! — Function

sysv!(uplo, A, B) -> (B, A, ipiv)

Находит решение для A * X = B для симметричной матрицы A. Если uplo = U, сохраняется верхняя половина матрицы A. Если uplo = L, сохраняется нижняя половина. Матрица B перезаписывается решением X. Матрица A перезаписывается ее разложением Банча-Кауфмана. ipiv содержит информацию о разложении.

# LinearAlgebra.LAPACK.sytrf! — Function

sytrf!(uplo, A) -> (A, ipiv, info)

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

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

# LinearAlgebra.LAPACK.sytri! — Function

sytri!(uplo, A, ipiv)

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

# LinearAlgebra.LAPACK.sytrs! — Function

sytrs!(uplo, A, ipiv, B)

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

# LinearAlgebra.LAPACK.hesv! — Function

hesv!(uplo, A, B) -> (B, A, ipiv)

Находит решение для A * X = B для эрмитовой матрицы A. Если uplo = U, сохраняется верхняя половина матрицы A. Если uplo = L, сохраняется нижняя половина. Матрица B перезаписывается решением X. Матрица A перезаписывается ее разложением Банча-Кауфмана. ipiv содержит информацию о разложении.

# LinearAlgebra.LAPACK.hetrf! — Function

hetrf!(uplo, A) -> (A, ipiv, info)

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

# LinearAlgebra.LAPACK.hetri! — Function

hetri!(uplo, A, ipiv)

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

# LinearAlgebra.LAPACK.hetrs! — Function

hetrs!(uplo, A, ipiv, B)

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

# LinearAlgebra.LAPACK.syev! — Function

syev!(jobz, uplo, A)

# LinearAlgebra.LAPACK.syevr! — Function

syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)

Находит собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A. Если uplo = U, используется верхний треугольник матрицы A. Если uplo = L, используется нижний треугольник матрицы A. Если range = A, будут найдены все собственные значения. Если range = V, будут найдены собственные значения в полуоткрытом интервале (vl, vu]. Если range = I, будут найдены собственные значения с индексами между il и iu. abstol можно задать как допуск на сходимость.

Собственные значения возвращаются в W, а собственные векторы — в Z.

# LinearAlgebra.LAPACK.sygvd! — Function

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

Находит обобщенные собственные значения (jobz = N) или собственные значения и собственные векторы (jobz = V) симметричной матрицы A и симметричной положительно определенной матрицы B. Если uplo = U, используются верхние треугольники матриц A и B. Если uplo = L, используются нижние треугольники матриц A и B. Если itype = 1, нужно решить задачу A * x = lambda * B * x. Если itype = 2, нужно решить задачу A * B * x = lambda * x. Если itype = 3, нужно решить задачу B * A * x = lambda * x.

# LinearAlgebra.LAPACK.bdsqr! — Function

bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

Вычисляет сингулярную декомпозицию двухдиагональной матрицы с d на диагонали и e_ вне диагонали. Если uplo = U, матрица e_ является наддиагональю. Если uplo = L, e_ является поддиагональю. При необходимости может также вычислять произведение Q' * C.

Возвращает сингулярные значения в d, и матрица C перезаписывается Q' * C.

# LinearAlgebra.LAPACK.bdsdc! — Function

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

Вычисляет разложение сингулярного значения двухдиагональной матрицы с d на диагонали и e_ вне диагонали с использованием подхода по принципу «разделяй и властвуй». Если uplo = U, e_ является наддиагональю. Если uplo = L, e_ является поддиагональю. Если compq = N, будут найдены только сингулярные значения. Если compq = I, будут найдены сингулярные значения и векторы. Если compq = P, сингулярные значения и векторы будут найдены в компактной форме. Работает только для вещественных типов.

Возвращает сингулярные значения в d, а если compq = P — компактные сингулярные векторы в iq.

# LinearAlgebra.LAPACK.gecon! — Function

gecon!(normtype, A, anorm)

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

# LinearAlgebra.LAPACK.gehrd! — Function

gehrd!(ilo, ihi, A) -> (A, tau)

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

# LinearAlgebra.LAPACK.orghr! — Function

orghr!(ilo, ihi, A, tau)

Явным образом находит Q, ортогональную или унитарную матрицу из функции gehrd!. ilo, ihi, A и tau должны соответствовать входным или выходным данным функции gehrd!.

# LinearAlgebra.LAPACK.gees! — Function

gees!(jobvs, A) -> (A, vs, w)

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

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

# LinearAlgebra.LAPACK.gges! — Function

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

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

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

# LinearAlgebra.LAPACK.trexc! — Function

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.

# LinearAlgebra.LAPACK.trsen! — Function

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.

# LinearAlgebra.LAPACK.tgsen! — Function

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

Переупорядочивает векторы обобщенного разложения Шура. select задает собственные значения в каждом кластере.

# LinearAlgebra.LAPACK.trsyl! — Function

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.

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

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