Linear Algebra

NoPivot

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

RowNonZero

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

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

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

RowMaximum

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

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

ColumnNorm

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

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

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

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

Примеры

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

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

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

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

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

См. также muladd, dot.

\(A, B)

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

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

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

См. также: factorize, pinv.

Примеры

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

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

julia> A * X == B
true

A / B

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

Смотрите также: rdiv!.

Примеры

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

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

julia> isapprox(A, X*B)
true

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

SingularException

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

PosDefException

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

ZeroPivotException <: Exception

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

RankDeficientException

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

LAPACKException

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

dot(x, y)
x ⋅ y

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

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

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

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

Примеры

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

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

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

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

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

julia> dot(x, y)
150.0

dot(x, A, y)

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

Примеры

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

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

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

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

Вычислите векторное произведение двух 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

axpy!(α, x::AbstractArray, y::AbstractArray)

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

Примеры

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

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

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

axpby!(α, x::AbstractArray, β, y::AbstractArray)

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

Примеры

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

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

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

rotate!(x, y, c, s)

Перезаписывает x как c*x + s*y и y как -conj(s)*x + c*y. Возвращает x и y.

reflect!(x, y, c, s)

Перезаписывает x значением c*x + s*y и y значением conj(s)*x - c*y. Возвращает x и y.

factorize(A)

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

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

Примеры

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

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

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

Diagonal(V::AbstractVector)

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

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

Примеры

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

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

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

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

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

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

Diagonal(A::AbstractMatrix)

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

Примеры

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

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

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

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

Diagonal{T}(undef, n)

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

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

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

Примеры

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

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

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

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

Bidiagonal(A, uplo::Symbol)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

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

Примеры

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

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

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

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]

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

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

Примеры

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

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

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

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

Tridiagonal(A)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Гермицианская(A::AbstractMatrix, uplo::Symbol=:U)

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

Чтобы вычислить гермицианскую часть A, используйте hermitianpart.

Примеры

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

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

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

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

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

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

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

LowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

UpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

UnitLowerTriangular(A::AbstractMatrix)

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

Примеры

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

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

UnitUpperTriangular(A::AbstractMatrix)

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

Примеры

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

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

UpperHessenberg(A::AbstractMatrix)

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

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

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

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

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

Примеры

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

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

UniformScaling{T<:Number}

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

Примеры

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

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

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

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

I

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

Примеры

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

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

(I::UniformScaling)(n::Integer)

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

Примеры

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

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

LinearAlgebra.Factorization

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

LU <: Factorization

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

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

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

Примеры

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

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

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

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

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

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

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

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

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

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

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

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

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

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

Связь между F и A следующая:

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

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

• \
• det

См. также lu!

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

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

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

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

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

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

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

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

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

Связь между F и A такова:

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

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

Примеры

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L фактор:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U фактор:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

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

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L фактор:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U фактор (с недостаточным рангом):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

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

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

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

См. также lu

Примеры

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

julia> F = lu(A);

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

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

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

lu! такой же, как lu, но экономит место, перезаписывая входные данные A, вместо создания копии. Исключение 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 фактор:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U фактор:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

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

Cholesky <: Factorization

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

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

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

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

Примеры

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

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

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

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

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

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

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

CholeskyPivoted

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

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

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

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

Примеры

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

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U фактор с рангом 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
перестановка:
4-элементный вектор{Int64}:
 4
 2
 3
 1

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

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

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

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

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

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

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

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

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

Примеры

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

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U фактор:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

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

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

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

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

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

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

Примеры

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

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U фактор с рангом 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
перестановка:
4-элементный вектор 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).

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

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

Примеры

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

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

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

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

julia> L = sparse(C.L);

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

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

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

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

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

julia> L = sparse(C.L);

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

julia> L * L' ≈ A
true

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

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

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

Смотрите также cholesky.

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

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

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

Получите LDLt факторизацию A + C*C', учитывая LDLt или LLt факторизацию F для A.

Возвращаемый фактор всегда является LDLt факторизацией.

Смотрите также lowrankupdate!, lowrankdowndate, lowrankdowndate!.

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

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

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

Получите LDLt факторизацию A + C*C', учитывая LDLt или LLt факторизацию F от A.

Возвращаемый фактор всегда является LDLt факторизацией.

Смотрите также lowrankdowndate!, lowrankupdate, lowrankupdate!.

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

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

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

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

Факторизации LLt преобразуются в LDLt.

Смотрите также lowrankupdate, lowrankdowndate, lowrankdowndate!.

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

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

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

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

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

Смотрите также lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Factorization

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

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

Примеры

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 фактор:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D фактор:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

Вычисляет разложение LDLt (т.е. $LDL^T$) для действительной симметричной тридиагональной матрицы 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

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

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

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

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

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

См. также ldlt.

QR <: Factorization

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

\[A = Q R\]

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

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

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

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

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

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

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

QRCompactWY <: Factorization

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

\[A = Q R\]

где $Q$ — это ортогональная/унитарная матрица, а $R$ — верхняя треугольная матрица. Это похоже на формат QR, за исключением того, что ортогональная/унитарная матрица $Q$ хранится в формате Compact WY ^{[Schreiber1989]}. Для размера блока $n_b$ он хранится как матрица $V$ размером m×n в нижнем трапециевидном формате и матрица $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$, состоящая из $b = \lceil \min(m,n) / n_b \rceil$ верхних треугольных матриц $T_j$ размером $n_b$×$n_b$ ($j = 1, ..., b-1$) и верхней трапециевидной матрицы $T_b'$ размером $n_b$×$\min(m,n) - (b-1) n_b$ ($j=b$), верхняя квадратная часть которой обозначается как $T_b$, удовлетворяющая

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

так что $v_i$ — это $i$-й столбец матрицы $V$, $\tau_i$ — это $i$-й элемент из [diag(T_1); diag(T_2); …; diag(T_b)], а $(V_1 \; V_2 \; ... \; V_b)$ — это левый блок размером m×min(m, n) матрицы $V$. При построении с использованием qr размер блока задается как $n_b = \min(m, n, 36)$.

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

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

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

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

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

QRPivoted <: Factorization

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

\[A P = Q R\]

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

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

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

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

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

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

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

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

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

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

Примеры

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} с 4 сохраненными элементами:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q фактор:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R фактор:
2×2 SparseMatrixCSC{Float64, Int64} с 2 сохраненными элементами:
 -1.41421    ⋅
   ⋅       -1.41421
Перестановка строк:
4-элементный вектор{Int64}:
 1
 3
 4
 2
Перестановка столбцов:
2-элементный вектор{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

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

\[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 или collect(F.Q). Если m<=n, то Matrix(F.Q) дает ортогональную матрицу размером m×m.

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

Примеры

julia> 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 фактор: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R фактор:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

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

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

Примеры

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 фактор: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R фактор:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

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

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

LQ <: Factorization

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

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

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

Примеры

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

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

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

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

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

lq(A) -> S::LQ

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

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

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

Примеры

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

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

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

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

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

lq!(A) -> LQ

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

BunchKaufman <: Factorization

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A оборачивается внутренне в Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D фактор:
2×2 Тридиагональная{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U фактор:
2×2 ЕдиничнаяВерхняяТреугольная{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
перестановка:
2-элементный 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 фактор:
2×2 Тридиагональная{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L фактор:
2×2 ЕдиничнаяНижняяТреугольная{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
перестановка:
2-элементный Vector{Int64}:
 2
 1

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

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

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

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

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

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

Примеры

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

julia> S = bunchkaufman(A) # A оборачивается внутренне в Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D фактор:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U фактор:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
перестановка:
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 фактор:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L фактор:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
перестановка:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

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

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

Eigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

GeneralizedEigen <: Factorization

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

Примеры

julia> eigvals(-2)
-2

eigvals(A, B) -> значения

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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), вместо создания копий.

Примеры

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

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

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

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

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

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

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

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

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

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

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

Примеры

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

julia> eigmax(A)
1.0

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

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` не может иметь комплексные собственные значения.
Stacktrace:
[...]

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

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

Примеры

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

julia> eigmin(A)
-1.0

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

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` не может иметь комплексные собственные значения.
Stacktrace:
[...]

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

eigvecs(A, B) -> Matrix

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

Примеры

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

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

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

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

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

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

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

Примеры

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

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

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

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

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

eigen(A, B; sortby) -> GeneralizedEigen

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

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

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

Примеры

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

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

julia> F = eigen(A, B);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hessenberg <: Факторизация

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

hessenberg(A) -> Hessenberg

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

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

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

Итерация разложения дает факторы F.Q, F.H, F.μ.

Примеры

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

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

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

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

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> Гессенберг

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

Schur <: Factorization

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

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

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

Примеры

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

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T фактор:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z фактор:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
собственные значения:
2-element Vector{Float64}:
  3.0
 -2.0

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

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

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

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

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

Итерация разложения производит компоненты F.S, F.T, F.Q, F.Z, F.α и F.β.

schur(A) -> F::Schur

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

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

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

Примеры

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

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

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

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

julia> t == F.T && z == F.Z && vals == F.values
true

schur(A, B) -> F::GeneralizedSchur

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

Итерация разложения производит компоненты F.S, F.T, F.Q, F.Z, F.α и F.β.

schur!(A) -> F::Schur

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

Примеры

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

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T фактор:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z фактор:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
собственные значения:
2-элементный Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

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

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

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

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

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

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

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

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

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

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

SVD <: Factorization

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

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

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

Примеры

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

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
сингулярные значения:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

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

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

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

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

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

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

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

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

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

Примеры

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

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

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

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

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

svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

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

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

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

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

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

Примеры

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, например, в сравнении генома человека и дрожжей, или сигнала и шума, или между кластерами и внутри кластеров. (См. обсуждение Эдельмана и Вана: https://arxiv.org/abs/1901.00485)

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

Примеры

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

julia> F = svd(A, B);

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

julia> H = R*Q';

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

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

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

julia> U == Uonly
true

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

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

svd!(A, B) -> ОбобщённоеSVD

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

svdvals(A)

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

Примеры

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

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

svdvals(A, B)

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

Примеры

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

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

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

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

svdvals!(A, B)

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

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

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

См. также givens.

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

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

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

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

y = G*x

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

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

См. также LinearAlgebra.Givens.

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

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

B = G*A

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

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

Смотрите также LinearAlgebra.Givens.

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

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

B = G*x

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

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

См. также LinearAlgebra.Givens.

triu(M)

Верхний треугольник матрицы.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

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

triu!(M, k::Integer)

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

Примеры

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

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

Нижний треугольник матрицы.

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

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

Примеры

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

Нижний треугольник матрицы, перезаписывая M в процессе. См. также tril.

tril!(M, k::Integer)

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

Примеры

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

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

AbstractRange, дающий индексы k-й диагонали матрицы M. При желании можно указать стиль индексации, который определяет тип возвращаемого диапазона. Если indstyle isa IndexLinear (по умолчанию), это возвращает AbstractRange{Integer}. С другой стороны, если indstyle isa IndexCartesian, это возвращает AbstractRange{CartesianIndex{2}}.

Если k не указан, предполагается, что он равен 0 (соответствует главной диагонали).

См. также: diag, diagm, Diagonal.

Примеры

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

julia> diagind(A, -1)
2:4:6

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

diag(M, k::Integer=0)

k-я диагональ матрицы, в виде вектора.

См. также diagm, diagind, Diagonal, isdiag.

Примеры

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

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

Создает матрицу из Pair диагоналей и векторов. Вектор kv.second будет размещен на диагонали kv.first. По умолчанию матрица квадратная, и ее размер определяется из kv, но можно указать прямоугольный размер m×n (дополняя нулями по мере необходимости), передав m,n в качестве первых аргументов. Для повторяющихся индексов диагоналей kv.first значения в соответствующих векторах kv.second будут складываться.

diagm создает полную матрицу; если вам нужны версии с эффективным хранением и быстрой арифметикой, смотрите Diagonal, Bidiagonal Tridiagonal и SymTridiagonal.

Примеры

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

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

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

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

Создает матрицу с элементами вектора в качестве диагональных элементов. По умолчанию матрица квадратная, и ее размер задается length(v), но можно указать прямоугольный размер m×n, передав m,n в качестве первых аргументов.

Примеры

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

rank(::QRSparse{Tv,Ti}) -> Ti

Возвращает ранг QR-разложения

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

Вычисляет ранг S, вычисляя его QR-факторизацию. Значения меньше tol считаются нулевыми. См. руководство SPQR.

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

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

Примеры

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

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

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

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

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

norm(A, p::Real=2)

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

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

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

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

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

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

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

Примеры

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

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

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

julia> norm(1:9)
16.881943016134134

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

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

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

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

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

Примеры

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

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

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

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

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

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

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

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

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

Примеры

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

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

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

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

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

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

Примеры

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

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

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

normalize(a, p::Real=2)

Нормализует a так, чтобы его p-норма равнялась единице, т.е. norm(a, p) == 1. Для скалярных значений это похоже на sign(a), за исключением того, что normalize(0) = NaN. См. также normalize!, norm и sign.

Примеры

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

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

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

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

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

Число обусловленности Скела $\kappa_S$ матрицы M, опционально относительно вектора x, вычисляемое с использованием оператора p-нормы. $\left\vert M \right\vert$ обозначает матрицу (поэлементных) абсолютных значений $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Допустимые значения для p — 1, 2 и Inf (по умолчанию).

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

tr(M)

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

Примеры

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

julia> tr(A)
5

det(M)

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

Смотрите также: logdet и logabsdet.

Примеры

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

julia> det(M)
2.0

logdet(M)

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

Примеры

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

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

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

Примеры

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

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

Обратная матрица. Вычисляет матрицу N, такую что M * N = I, где I — это единичная матрица. Вычисляется путем решения левой деления N = M \ I.

Примеры

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

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # будет устаревшим в Julia 2.0

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

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

Оптимальный выбор абсолютной (atol) и относительной точности (rtol) варьируется как в зависимости от значения M, так и от предполагаемого применения псдониверса. Значение относительной точности по умолчанию равно n*ϵ, где n — это размер наименьшего измерения M, а ϵ — это eps типа элементов M.

Для инверсии плотных плохо обусловленных матриц в смысле наименьших квадратов рекомендуется использовать rtol = sqrt(eps(real(float(oneunit(eltype(M)))))).

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

Примеры

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

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

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

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # будет устаревшим в Julia 2.0

Вычисляет базис для нулевого пространства `M`, включая сингулярные векторы `M`, чьи сингулярные значения имеют величину меньше, чем `max(atol, rtol*σ₁)`, где `σ₁` — это наибольшее сингулярное значение `M`.

По умолчанию относительная точность `rtol` равна `n*ϵ`, где `n` — это размер наименьшего измерения `M`, а `ϵ` — это [`eps`](@ref) типа элементов `M`.

# Примеры

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

julia> nullspace(M) 3×1 Matrix{Float64}: 0.0 0.0 1.0

julia> nullspace(M, rtol=3) 3×3 Matrix{Float64}: 0.0 1.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0

julia> nullspace(M, atol=0.95) 3×1 Matrix{Float64}: 0.0 0.0 1.0 ```

kron(A, B)

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

Для вещественных векторов v и w произведение Кронекера связано с внешним произведением через kron(v,w) == vec(w * transpose(v)) или w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). Обратите внимание, как порядок v и w отличается слева и справа от этих выражений (из-за хранения по столбцам). Для комплексных векторов внешнее произведение w * v' также отличается конъюгацией v.

Примеры

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

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

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

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

exp(A::AbstractMatrix)

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

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

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

Примеры

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

cis(A::AbstractMatrix)

Более эффективный метод для exp(im*A) квадратной матрицы A (особенно если A является Гермицианской или вещественной Симметричной).

См. также cispi, sincos, exp.

Примеры

julia> cis([π 0; 0 π]) ≈ -I
true

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

Степень матрицы, эквивалентная $\exp(p\log(A))$

Примеры

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

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

Матрица экспонента, эквивалентная $\exp(\log(b)A)$.

Примеры

julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::AbstractMatrix)

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

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

Примеры

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

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(x)

Возвращает $\sqrt{x}$.

Вызывает DomainError для отрицательных Real аргументов. Вместо этого используйте комплексные отрицательные аргументы. Обратите внимание, что sqrt имеет разрыв вдоль отрицательной действительной оси.

Префиксный оператор √ эквивалентен sqrt.

Смотрите также: hypot.

Примеры

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im находится ниже разрыва
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

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

Если A является действительно-симметричной или эрмитовой, то для вычисления квадратного корня используется её собственное разложение (eigen). Для таких матриц собственные значения λ, которые кажутся слегка отрицательными из-за ошибок округления, рассматриваются как нулевые. Более точно, матрицы со всеми собственными значениями ≥ -rtol*(max |λ|) рассматриваются как полуположительные (что приводит к эрмитовому квадратному корню), при этом отрицательные собственные значения принимаются за ноль. rtol — это именованный аргумент для sqrt (только в случае эрмитовых/действительно-симметричных матриц), который по умолчанию равен машинной точности, масштабированной по size(A,1).

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

Примеры

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

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cbrt(A::AbstractMatrix{<:Real})

Вычисляет кубический корень действительной матрицы A. Если T = cbrt(A), то мы имеем T*T*T ≈ A, см. пример ниже.

Если A симметрична, т.е. имеет тип HermOrSym{<:Real}, то для нахождения кубического корня используется (eigen). В противном случае используется специализированная версия алгоритма p-го корня ^[S03], которая использует действительное разложение Шура (schur) для вычисления кубического корня.

Примеры

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

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

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

Примеры

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

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

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

Примеры

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

sincos(A::AbstractMatrix)

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

Примеры

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

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

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

Примеры

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

Примеры

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

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

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

Примеры

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

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

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

Примеры

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

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

asinh(A::AbstractMatrix)

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

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

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

Примеры

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

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

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
true

sylvester(A, B, C)

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

Примеры

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

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

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

Проверьте, что факторизация матрицы удалась.

Примеры

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

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

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

Примеры

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

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

Примеры

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

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

Смотрите также isposdef!, cholesky.

Примеры

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

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

Примеры

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

Проверьте, является ли A нижней треугольной матрицей, начиная с k-й наддиагонали.

Примеры

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(c)
false

julia> istril(c, 1)
true

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

Проверьте, является ли A верхней треугольной матрицей, начиная с k-й супердиагонали.

Примеры

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

Проверьте, является ли матрица диагональной в том смысле, что iszero(A[i,j]) истинно, если i != j. Обратите внимание, что не обязательно, чтобы A была квадратной; если вы также хотите это проверить, вам нужно убедиться, что size(A, 1) == size(A, 2).

Примеры

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

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

julia> isdiag(c)
true

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

julia> isdiag(d)
false

ishermitian(A) -> Bool

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

Примеры

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

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

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

Примеры

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

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # транспозиция транспозиции разворачивает родителя
true

julia> Transpose(B) # однако, конструктор всегда оборачивает свой аргумент
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # изменение B автоматически изменит A

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

Для комплексных матриц операция adjoint эквивалентна сопряженной транспозиции.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

Транспозиция AbstractVector является строковым вектором:

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

julia> transpose(v) # возвращает строковый вектор
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # вычисление скалярного произведения
14

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # построение блочной матрицы
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # блоки рекурсивно транспонируются
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

Ленивая транспонирование факторизации F. По умолчанию возвращает TransposeFactorization, за исключением Factorization с действительным eltype, в этом случае возвращает AdjointFactorization.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

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

См. halfperm!

transpose!(dest,src)

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

Примеры

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

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

julia> transpose!(B, A);

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

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

Транспонирование

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

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

Примеры

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

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

Ленивая обертка для транспонированного объекта Factorization. Обычно конструктор TransposeFactorization не следует вызывать напрямую, вместо этого используйте transpose(:: Factorization).

A'
adjoint(A)

Ленивая сопряженная (конъюгированная транспозиция). Обратите внимание, что adjoint применяется рекурсивно к элементам.

Для числовых типов adjoint возвращает комплексно-сопряженное значение, и, следовательно, эквивалентен функции идентичности для вещественных чисел.

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

Примеры

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

julia> B = A' # эквивалентно adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # сопряженное значение от сопряженного значения разворачивает родителя
true

julia> Adjoint(B) # однако, конструктор всегда оборачивает свой аргумент
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # изменение B автоматически изменит A

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Для вещественных матриц операция adjoint эквивалентна transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

Сопряженное значение AbstractVector - это строковый вектор:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # вычислить скалярное произведение, эквивалентно x' * x
25 + 0im

Для матрицы матриц отдельные блоки обрабатываются рекурсивно:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint(F::Factorization)

Ленивая адъюнктная функция факторизации F. По умолчанию возвращает обертку AdjointFactorization.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

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

См. halfperm!

adjoint!(dest,src)

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

Примеры

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

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

julia> adjoint!(B, A);

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

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

Сопряженный

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

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

Примеры

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

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

Ленивая обертка для адъюнкта основного объекта Factorization. Обычно конструктор AdjointFactorization не следует вызывать напрямую, вместо этого используйте adjoint(:: Factorization).

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

С нетерпением оценивайте ленивую транспонированную/сопряженную матрицу. Обратите внимание, что транспонирование применяется рекурсивно к элементам.

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

Примеры

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

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

Вернуть расстояние между последовательными элементами массива в размерности 1 в единицах размера элемента.

Примеры

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

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

Примеры

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

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

Если указан аргумент ключевого слова eltype, peakflops создаст матрицы с элементами типа eltype для вычисления пикового значения flop.

По умолчанию peakflops будет использовать лучшее время из 3 испытаний. Если указан аргумент ключевого слова ntrials, peakflops будет использовать указанное количество испытаний для выбора лучшего времени.

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

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Возвращает гермитову часть квадратной матрицы A, определяемую как (A + A') / 2, в виде матрицы Hermitian. Для вещественных матриц A это также известно как симметрическая часть A; это также иногда называют "действительной частью оператора". Необязательный аргумент uplo управляет соответствующим аргументом представления Hermitian. Для вещественных матриц последнее эквивалентно представлению Symmetric.

Смотрите также hermitianpart! для соответствующей операции на месте.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Перезапишите квадратную матрицу A на месте с её гермитовой частью (A + A') / 2 и верните Hermitian(A, uplo). Для вещественных матриц A это также известно как симметричная часть A.

Смотрите также hermitianpart для соответствующей операции вне места.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с адъюнкцией следующим образом:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Более того, параметры диапазона индексов должны удовлетворять length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Эффективно копирует элементы матрицы A в B с транспонированием следующим образом:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

Элементы B[ir_dest, jr_dest] перезаписываются. Более того, параметры диапазона индексов должны удовлетворять length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Эффективно копирует элементы матрицы M в B, в зависимости от параметра символа tM, следующим образом:

Элементы B[ir_dest, jr_dest] перезаписываются. Кроме того, параметры диапазона индексов должны удовлетворять length(ir_dest) == length(jr_src) и length(jr_dest) == length(ir_src).

Смотрите также copyto! и copy_adjoint!.

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

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

Примеры

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);

julia> mul!(Y, A, B) === Y
true

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

julia> Y == A * B
true

Реализация

Для пользовательских типов матриц и векторов рекомендуется реализовать mul! с 5 аргументами, а не реализовывать mul! с 3 аргументами напрямую, если это возможно.

mul!(C, A, B, α, β) -> C

Совместное умножение-сложение матриц или векторов $A B α + C β$ с изменением на месте. Результат сохраняется в C, перезаписывая его. Обратите внимание, что C не должен быть алиасом ни для A, ни для B.

Примеры

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

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

julia> C_original = [1.0 2.0; 3.0 4.0]; # Копия оригинального значения C

julia> C == A * B * α + C_original * β
true

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

Масштабирует массив B на скаляр a, перезаписывая B на месте. Используйте rmul!, чтобы умножить скаляр справа. Операция масштабирования уважает семантику умножения * между a и элементом B. В частности, это также относится к умножению, включающему конечные числа, такие как NaN и ±Inf.

Примеры

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

Вычисляет произведение матриц $AB$, перезаписывая B, и возвращает результат. Здесь A должен быть специальным типом матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторым ортогональным типом, см. QR.

Примеры

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

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

Масштабирует массив A на скаляр b, перезаписывая A на месте. Используйте lmul!, чтобы умножить скаляр слева. Операция масштабирования уважает семантику умножения * между элементом A и b. В частности, это также относится к умножению, включающему конечные числа, такие как NaN и ±Inf.

Примеры

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

Вычисляет произведение матриц $AB$, перезаписывая A, и возвращает результат. Здесь B должен быть специальным типом матрицы, например, Diagonal, UpperTriangular или LowerTriangular, или некоторым ортогональным типом, см. QR.

Примеры

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

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

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

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

Примеры

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

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

julia> Y = zero(X);

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

julia> Y ≈ A\X
true

ldiv!(A, B)

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

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

Примеры

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

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

julia> Y = copy(X);

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

julia> X ≈ A\Y
true

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

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

Примеры

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

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

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

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

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.

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

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

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

get_num_threads()

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

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.

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

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

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

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

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

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

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

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

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

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

Примеры

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

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

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

Примеры

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

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

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

Примеры

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

nrm2(n, X, incx)

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

Примеры

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

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

asum(n, X, incx)

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

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

Примеры

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

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

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

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

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

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

gemv(tA, alpha, A, x)

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

gemv(tA, A, x)

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

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

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

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

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

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

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

hemv(ul, alpha, A, x)

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

hemv(ul, A, x)

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

hpmv!(uplo, α, AP, x, β, y)

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

При uplo = 'U' массив AP должен содержать верхнюю треугольную часть эрмитовой матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

При uplo = 'L' массив AP должен содержать нижнюю треугольную часть эрмитовой матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

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

Массивы x, y и AP должны быть типа ComplexF32 или ComplexF64.

Верните обновленный y.

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

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

symv(ul, alpha, A, x)

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

symv(ul, A, x)

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

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

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

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

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

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

sbmv(uplo, k, A, x)

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

spmv!(uplo, α, AP, x, β, y)

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

При uplo = 'U' массив AP должен содержать верхнюю треугольную часть симметрической матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

При uplo = 'L' массив AP должен содержать нижнюю треугольную часть симметрической матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

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

Массивы x, y и AP должны быть типа Float32 или Float64.

Верните обновленный y.

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

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

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

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

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

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

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

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

ger!(alpha, x, y, A)

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

her!(uplo, alpha, x, A)

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

syr!(uplo, alpha, x, A)

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

spr!(uplo, α, x, AP)

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

При uplo = 'U' массив AP должен содержать верхнюю треугольную часть симметричной матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[1, 2] и A[2, 2] соответственно, и так далее.

При uplo = 'L' массив AP должен содержать нижнюю треугольную часть симметричной матрицы, упакованную последовательно, по столбцам, так что AP[1] содержит A[1, 1], AP[2] и AP[3] содержат A[2, 1] и A[3, 1] соответственно, и так далее.

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

Массивы x и AP должны быть типа Float32 или Float64. Верните обновленный AP.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

Обновите нижнюю или верхнюю треугольную часть, указанную uplo, матрицы C как alpha*A*B + beta*C или другие варианты в зависимости от tA и tB. Верните обновленную матрицу C.

gemmt(uplo, tA, tB, alpha, A, B)

Возвращает нижнюю или верхнюю треугольную часть, указанную uplo, от A*B или других трех вариантов в зависимости от tA и tB.

gemmt(uplo, tA, tB, A, B)

Возвращает нижнюю или верхнюю треугольную часть, указанную uplo, от A*B или другие три варианта в зависимости от tA и tB.

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

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

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

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

gemm(tA, tB, A, B)

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