AbstractSparseArray{Tv,Ti,N}

Надтип для N-мерных разреженных массивов (или похожих на массивы типов) с элементами типа Tv и типом индекса Ti. SparseMatrixCSC, SparseVector и SuiteSparse.CHOLMOD.Sparse являются подтипами этого.

AbstractSparseVector{Tv,Ti}

Надтип для одномерных разреженных массивов (или похожих на массивы типов) с элементами типа Tv и типом индекса Ti. Псевдоним для AbstractSparseArray{Tv,Ti,1}.

AbstractSparseMatrix{Tv,Ti}

Надтип для двумерных разреженных массивов (или похожих на массивы типов) с элементами типа Tv и типом индекса Ti. Псевдоним для AbstractSparseArray{Tv,Ti,2}.

SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}

Тип вектора для хранения разреженных векторов. Можно создать, передав длину вектора, отсортированный вектор ненулевых индексов и вектор ненулевых значений.

Например, вектор [5, 6, 0, 7] можно представить как

SparseVector(4, [1, 2, 4], [5, 6, 7])

Это указывает, что элемент с индексом 1 равен 5, с индексом 2 равен 6, с индексом 3 равен zero(Int), а с индексом 4 равен 7.

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

sparse([5, 6, 0, 7])

что даёт тот же разреженный вектор.

SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrixCSC{Tv,Ti}

Тип матрицы для хранения разреженных матриц в формате Сжатых столбцов. Стандартный способ создания SparseMatrixCSC — через функцию sparse. Также см. spzeros, spdiagm и sprand.

sparse(A)

Преобразовать AbstractMatrix A в разреженную матрицу.

Примеры

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

julia> sparse(A)
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅
  ⋅   1.0   ⋅
  ⋅    ⋅   1.0

sparse(I, J, V,[ m, n, combine])

Создать разреженную матрицу S с размерами m x n так, что S[I[k], J[k]] = V[k]. Функция combine используется для объединения дубликатов. Если m и n не указаны, они устанавливаются соответственно в maximum(I) и maximum(J). Если функция combine не задана, combine по умолчанию равно +, если элементы V не являются булевыми значениями, в противном случае combine по умолчанию равно |. Все элементы I должны удовлетворять условию 1 <= I[k] <= m, а все элементы J должны удовлетворять условию 1 <= J[k] <= n. Числовые нули в (I, J, V) сохраняются как структурные ненулевые элементы; чтобы удалить числовые нули, используйте dropzeros!.

Для дополнительной документации и экспертного драйвера, см. SparseArrays.sparse!.

Примеры

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

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

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

julia> sparse(Is, Js, Vs)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 1  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  3

sparse!(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv},
        m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv},
        [csccolptr::Vector{Ti}], [cscrowval::Vector{Ti}, cscnzval::Vector{Tv}] ) where {Tv,Ti<:Integer}

Родитель и экспертный драйвер для sparse; см. sparse для базового использования. Этот метод позволяет пользователю предоставить предварительно выделенную память для промежуточных объектов и результата sparse, как описано ниже. Это позволяет более эффективно последовательно строить SparseMatrixCSC из представлений координат, а также позволяет извлечь неотсортированное представление столбцов транспонированного результата без дополнительных затрат.

Этот метод состоит из трех основных этапов: (1) Сортировка по подсчету предоставленного представления координат в неотсортированную форму CSR по строкам, включая повторяющиеся элементы. (2) Проход по форме CSR, одновременно вычисляя массив указателей столбцов желаемой формы CSC, обнаруживая повторяющиеся элементы и переупаковывая форму CSR, объединяя повторяющиеся элементы; на этом этапе получается неотсортированная форма CSR по строкам без повторяющихся элементов. (3) Сортировка по подсчету предыдущей формы CSR в полную отсортированную форму CSC без повторяющихся элементов.

Входные массивы csrrowptr, csrcolval, и csrnzval составляют хранилище для промежуточных форм CSR и требуют length(csrrowptr) >= m + 1, length(csrcolval) >= length(I), и length(csrnzval >= length(I)). Входной массив klasttouch, рабочее пространство для второго этапа, требует length(klasttouch) >= n. Необязательные входные массивы csccolptr, cscrowval, и cscnzval составляют хранилище для возвращаемой формы CSC S. При необходимости эти массивы автоматически изменяются для удовлетворения length(csccolptr) = n + 1, length(cscrowval) = nnz(S) и length(cscnzval) = nnz(S); следовательно, если nnz(S) неизвестно изначально, достаточно передать пустые векторы соответствующего типа (Vector{Ti}() и Vector{Tv}() соответственно), или вызвать метод sparse!, опуская cscrowval и cscnzval.

При возврате csrrowptr, csrcolval, и csrnzval содержат неотсортированное представление столбцов транспонированного результата.

Вы можете повторно использовать хранилище входных массивов (I, J, V) для выходных массивов (csccolptr, cscrowval, cscnzval). Например, вы можете вызвать sparse!(I, J, V, csrrowptr, csrcolval, csrnzval, I, J, V). Обратите внимание, что они будут изменены для соответствия вышеуказанным условиям.

В целях повышения эффективности этот метод не выполняет проверки аргументов, кроме 1 <= I[k] <= m и 1 <= J[k] <= n. Используйте с осторожностью. Тестирование с --check-bounds=yes разумно.

Этот метод работает за время O(m, n, length(I)) . Алгоритм HALFPERM, описанный в F. Gustavson, "Two fast algorithms for sparse matrices: multiplication and permuted transposition," ACM TOMS 4(3), 250-269 (1978), вдохновил использование этого метода пары сортировок подсчетом.

SparseArrays.sparse!(I, J, V, [m, n, combine]) -> SparseMatrixCSC

Вариант sparse!, который повторно использует входные векторы (I, J, V ) для хранения конечной матрицы. После построения входные векторы будут алиасами буферов матрицы; S.colptr === I, S.rowval === J, и S.nzval === V хранит, и они будут resize!d по мере необходимости.

Обратите внимание, что некоторые буферы работы все еще будут выделены. В частности, этот метод является удобной оболочкой вокруг sparse!(I, J, V, m, n, combine, klasttouch, csrrowptr, csrcolval, csrnzval, csccolptr, cscrowval, cscnzval), где этот метод выделяет klasttouch, csrrowptr, csrcolval, и csrnzval соответствующего размера, но повторно использует I, J, и V для csccolptr, cscrowval, и cscnzval.

Аргументы m, n, и combine по умолчанию maximum(I), maximum(J), и + соответственно.

sparsevec(I, V, [m, combine])

Создать разреженный вектор S длины m так, что S[I[k]] = V[k]. Дубликаты объединяются с помощью функции combine, которая по умолчанию равна +, если аргумент combine не задан, если элементы V не булевые, в противном случае combine по умолчанию равно |.

Примеры

julia> II = [1, 3, 3, 5]; V = [0.1, 0.2, 0.3, 0.2];

julia> sparsevec(II, V)
5-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  0.5
  [5]  =  0.2

julia> sparsevec(II, V, 8, -)
8-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  -0.1
  [5]  =  0.2

julia> sparsevec([1, 3, 1, 2, 2], [true, true, false, false, false])
3-element SparseVector{Bool, Int64} with 3 stored entries:
  [1]  =  1
  [2]  =  0
  [3]  =  1

sparsevec(d::Dict, [m])

Создать разреженный вектор длины m где ненулевые индексы — это ключи из словаря, а ненулевые значения — значения из словаря.

Примеры

julia> sparsevec(Dict(1 => 3, 2 => 2))
2-element SparseVector{Int64, Int64} with 2 stored entries:
  [1]  =  3
  [2]  =  2

sparsevec(A)

Преобразовать вектор A в разреженный вектор длины m.

Примеры

julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
6-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  2.0
  [5]  =  3.0

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

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

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

issparse(S)

Возвращает true если S является разреженным, и false в противном случае.

Примеры

julia> sv = sparsevec([1, 4], [2.3, 2.2], 10)
10-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  2.3
  [4]  =  2.2

julia> issparse(sv)
true

julia> issparse(Array(sv))
false

nnz(A)

Возвращает количество хранимых (заполненных) элементов в разреженном массиве.

Примеры

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> nnz(A)
3

findnz(A::SparseMatrixCSC)

Возвращает кортеж (I, J, V), где I и J — индексы строк и столбцов хранимых («структурно ненулевых») значений в разреженной матрице A, и V — вектор значений.

Примеры

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

julia> findnz(A)
([1, 1, 3, 2], [1, 2, 2, 3], [1, 2, 4, 3])

spzeros([type,]m[,n])

Создайте разреженный вектор длины m или разреженную матрицу размера m x n. Этот разреженный массив не будет содержать ненулевых значений. Во время создания не будет выделено памяти для ненулевых значений. Тип по умолчанию — Float64, если не указан другой.

Примеры

julia> spzeros(3, 3)
3×3 SparseMatrixCSC{Float64, Int64} with 0 stored entries:
  ⋅    ⋅    ⋅
  ⋅    ⋅    ⋅
  ⋅    ⋅    ⋅

julia> spzeros(Float32, 4)
4-element SparseVector{Float32, Int64} with 0 stored entries

spzeros([type], I::AbstractVector, J::AbstractVector, [m, n])

Создайте разреженную матрицу S размерности m x n со структурными нулями в S[I[k], J[k]].

Этот метод можно использовать для построения структуры разреженности матрицы, и он более эффективен, чем, например, sparse(I, J, zeros(length(I))).

Для дополнительной документации и экспертного драйвера см. SparseArrays.spzeros!.

spzeros!(::Type{Tv}, I::AbstractVector{Ti}, J::AbstractVector{Ti}, m::Integer, n::Integer,
         klasttouch::Vector{Ti}, csrrowptr::Vector{Ti}, csrcolval::Vector{Ti},
         [csccolptr::Vector{Ti}], [cscrowval::Vector{Ti}, cscnzval::Vector{Tv}]) where {Tv,Ti<:Integer}

Родитель и экспертный драйвер для spzeros(I, J), позволяющий пользователю предоставить предварительно выделенную память для промежуточных объектов. Этот метод — к spzeros что SparseArrays.sparse! к sparse. См. документацию для SparseArrays.sparse! для получения подробностей и необходимых длин буферов.

SparseArrays.spzeros!(::Type{Tv}, I, J, [m, n]) -> SparseMatrixCSC{Tv}

Вариант spzeros!, который повторно использует входные векторы I и J для хранения конечной матрицы. После построения входные векторы станут псевдонимами буферов матрицы; S.colptr === I и S.rowval === J будут содержать, и они будут resize! как потребуется.

Обратите внимание, что все же будут выделены некоторые вспомогательные буферы. Конкретно, этот метод является удобной оболочкой вокруг spzeros!(Tv, I, J, m, n, klasttouch, csrrowptr, csrcolval, csccolptr, cscrowval), где этот метод выделяет klasttouch, csrrowptr, и csrcolval соответствующего размера, но повторно использует I и J для csccolptr и cscrowval.

Аргументы m и n по умолчанию maximum(I) и maximum(J).

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

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

Примеры

julia> spdiagm(-1 => [1,2,3,4], 1 => [4,3,2,1])
5×5 SparseMatrixCSC{Int64, Int64} with 8 stored entries:
 ⋅  4  ⋅  ⋅  ⋅
 1  ⋅  3  ⋅  ⋅
 ⋅  2  ⋅  2  ⋅
 ⋅  ⋅  3  ⋅  1
 ⋅  ⋅  ⋅  4  ⋅

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

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

Примеры

julia> spdiagm([1,2,3])
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 1  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  3

julia> spdiagm(sparse([1,0,3]))
3×3 SparseMatrixCSC{Int64, Int64} with 2 stored entries:
 1  ⋅  ⋅
 ⋅  ⋅  ⋅
 ⋅  ⋅  3

sparse_hcat(A...)

Конкатенация по размерности 2. Возвращает объект SparseMatrixCSC.

sparse_vcat(A...)

Конкатенация по размерности 1. Возвращает объект SparseMatrixCSC.

sparse_hvcat(rows::Tuple{Vararg{Int}}, values...)

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

blockdiag(A...)

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

Примеры

julia> blockdiag(sparse(2I, 3, 3), sparse(4I, 2, 2))
5×5 SparseMatrixCSC{Int64, Int64} with 5 stored entries:
 2  ⋅  ⋅  ⋅  ⋅
 ⋅  2  ⋅  ⋅  ⋅
 ⋅  ⋅  2  ⋅  ⋅
 ⋅  ⋅  ⋅  4  ⋅
 ⋅  ⋅  ⋅  ⋅  4

sprand([rng],[T::Type],m,[n],p::AbstractFloat)
sprand([rng],m,[n],p::AbstractFloat,[rfn=rand])

Создайте случайный вектор длины m или m на n разреженную матрицу, в которой вероятность любого элемента быть ненулевым независимо задается p (и, следовательно, средняя плотность ненулевых элементов также точно p). Дополнительный аргумент rng задаёт генератор случайных чисел, см. Случайные числа. Дополнительный аргумент T задаёт тип элемента, по умолчанию Float64.

По умолчанию ненулевые значения выбираются из равномерного распределения с помощью функции rand, т. е. rand(T), или rand(rng, T), если rng указан; для значения по умолчанию T=Float64, это соответствует ненулевым значениям, равномерно выбираемым из [0,1).

Вы можете выбрать ненулевые значения из другого распределения, передав пользовательскую функцию rfn вместо rand . Это должна быть функция rfn(k), которая возвращает массив из k случайных чисел, выбираемых из желаемого распределения; в качестве альтернативы, если rng указан, она должна быть функцией rfn(rng, k).

Примеры

julia> sprand(Bool, 2, 2, 0.5)
2×2 SparseMatrixCSC{Bool, Int64} with 2 stored entries:
 1  1
 ⋅  ⋅

julia> sprand(Float64, 3, 0.75)
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  0.795547
  [2]  =  0.49425

sprandn([rng][,Type],m[,n],p::AbstractFloat)

Создайте случайный разреженный вектор длины m или разреженную матрицу размера m на n с заданной (независимой) вероятностью p любого элемента быть ненулевым, где ненулевые значения выбираются из нормального распределения. Дополнительный аргумент rng задаёт генератор случайных чисел, см. Случайные числа.

Примеры

julia> sprandn(2, 2, 0.75)
2×2 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 -1.20577     ⋅
  0.311817  -0.234641

nonzeros(A)

Возвращает вектор структурных ненулевых значений в разреженном массиве A. Это включает нули, которые явным образом хранятся в разреженном массиве. Возвращаемый вектор напрямую ссылается на внутреннее хранилище ненулевых значений A, и любые изменения в возвращаемом векторе изменят также A. См. rowvals и nzrange.

Примеры

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> nonzeros(A)
3-element Vector{Int64}:
 2
 2
 2

rowvals(A::AbstractSparseMatrixCSC)

Возвращает вектор индексов строк A. Любые изменения в возвращаемом векторе изменят также A. Предоставление доступа к тому, как хранятся индексы строк, может быть полезно в сочетании с итерацией по структурно ненулевым значениям. См. также nonzeros и nzrange.

Примеры

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> rowvals(A)
3-element Vector{Int64}:
 1
 2
 3

nzrange(A::AbstractSparseMatrixCSC, col::Integer)

Возвращает диапазон индексов к структурно ненулевым значениям столбца разреженной матрицы. В сочетании с nonzeros и rowvals это позволяет удобно итерировать по разреженной матрице :

A = sparse(I,J,V)
rows = rowvals(A)
vals = nonzeros(A)
m, n = size(A)
for j = 1:n
   for i in nzrange(A, j)
      row = rows[i]
      val = vals[i]
      # perform sparse wizardry...
   end
end

nzrange(x::SparseVectorUnion, col)

Указывает диапазон индексов ненулевых структурных значений разреженного вектора. Индекс столбца col игнорируется (предполагается, что он 1).

droptol!(A::AbstractSparseMatrixCSC, tol)

Удаляет сохранённые значения из A, модуль которых меньше или равен tol.

droptol!(x::AbstractCompressedVector, tol)

Удаляет сохранённые значения из x, модуль которых меньше или равен tol.

dropzeros!(x::AbstractCompressedVector)

Удаляет сохранённые числовые нули из x.

Для варианта вне места, см. dropzeros. Для информации об алгоритме, см. fkeep!.

dropzeros(A::AbstractSparseMatrixCSC;)

Создаёт копию A и удаляет из неё сохранённые числовые нули.

Для версии в формате «на месте» и алгоритмической информации см. dropzeros!.

Примеры

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

julia> dropzeros(A)
3×3 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 1.0   ⋅    ⋅
  ⋅    ⋅    ⋅
  ⋅    ⋅   1.0

dropzeros(x::AbstractCompressedVector)

Создаёт копию x и удаляет числовые нули из этой копии.

Для версии в формате «на месте» и алгоритмической информации см. dropzeros!.

Примеры

julia> A = sparsevec([1, 2, 3], [1.0, 0.0, 1.0])
3-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  0.0
  [3]  =  1.0

julia> dropzeros(A)
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

permute(A::AbstractSparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
        q::AbstractVector{<:Integer}) where {Tv,Ti}

Билатерально переставляет A, возвращая PAQ (A[p,q]). Длина столбцовой перестановки q должна совпадать с количеством столбцов A (length(q) == size(A, 2)). Длина строчной перестановки p должна совпадать с количеством строк A (length(p) == size(A, 1)).

Для опытных пользователей и дополнительной информации см. permute!.

Примеры

julia> A = spdiagm(0 => [1, 2, 3, 4], 1 => [5, 6, 7])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 1  5  ⋅  ⋅
 ⋅  2  6  ⋅
 ⋅  ⋅  3  7
 ⋅  ⋅  ⋅  4

julia> permute(A, [4, 3, 2, 1], [1, 2, 3, 4])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 ⋅  ⋅  ⋅  4
 ⋅  ⋅  3  7
 ⋅  2  6  ⋅
 1  5  ⋅  ⋅

julia> permute(A, [1, 2, 3, 4], [4, 3, 2, 1])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 ⋅  ⋅  5  1
 ⋅  6  2  ⋅
 7  3  ⋅  ⋅
 4  ⋅  ⋅  ⋅

permute!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
         [C::AbstractSparseMatrixCSC{Tv,Ti}]) where {Tv,Ti}

Билатерально переставляет A, сохраняя результат PAQ (A[p,q]) в X. Сохраняет промежуточный результат (AQ)^T (transpose(A[:,q])) в необязательном аргументе C при его наличии. Требуется, чтобы ни X, ни A, ни, при наличии, C не являлись алиасами друг друга; для сохранения результата PAQ обратно в A, используйте следующий метод без X:

permute!(A::AbstractSparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
         q::AbstractVector{<:Integer}[, C::AbstractSparseMatrixCSC{Tv,Ti},
         [workcolptr::Vector{Ti}]]) where {Tv,Ti}

Размеры X должны совпадать с размерами A (size(X, 1) == size(A, 1) и size(X, 2) == size(A, 2)), и X должно иметь достаточно места для размещения всех выделенных записей в A (length(rowvals(X)) >= nnz(A) и length(nonzeros(X)) >= nnz(A)). Длина столбцовой перестановки q должна совпадать с количеством столбцов A (length(q) == size(A, 2)). Длина строчной перестановки p должна совпадать с количеством строк A (length(p) == size(A, 1)).

Размеры C должны совпадать с размерами transpose(A) (size(C, 1) == size(A, 2) и size(C, 2) == size(A, 1)). и C должно иметь достаточно места для размещения всех выделенных записей в A (length(rowvals(C)) >= nnz(A) и length(nonzeros(C)) >= nnz(A)).

Для дополнительной (алгоритмической) информации и для версий этих методов, которые обходятся без проверки аргументов, см. (неэкспортированные) родительские методы unchecked_noalias_permute! и unchecked_aliasing_permute!.

См. также permute.

halfperm!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{TvA,Ti},
          q::AbstractVector{<:Integer}, f::Function = identity) where {Tv,TvA,Ti}

Перестановка столбцов и транспонирование A, одновременно применяя f к каждой записи A, сохраняя результат (f(A)Q)^T (map(f, transpose(A[:,q]))) в X.

Тип элемента Tv X должен совпадать с f(::TvA), где TvA - тип элемента A.

Размеры X должны совпадать с размерами transpose(A) (size(X, 1) == size(A, 2) и size(X, 2) == size(A, 1)), и X должно иметь достаточно места для размещения всех выделенных записей в A (length(rowvals(X)) >= nnz(A) и length(nonzeros(X)) >= nnz(A)). Длина столбцовой перестановки q должна совпадать с количеством столбцов A (length(q) == size(A, 2)).

Этот метод является родителем нескольких методов, выполняющих операции транспонирования и перестановки над SparseMatrixCSC. Поскольку этот метод не выполняет проверки аргументов, предпочтительнее использовать безопасные дочерние методы ([c]transpose[!], permute[!]) вместо прямого использования.

Этот метод реализует алгоритм HALFPERM, описанный в работе Ф. Густавсона «Два быстрых алгоритма для разреженных матриц: умножение и переставленное транспонирование», ACM TOMS 4(3), 250-269 (1978). Алгоритм работает за время O(size(A, 1), size(A, 2), nnz(A)) и не требует памяти, превышающей ту, что передана в качестве аргумента.

ftranspose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}, f::Function) where {Tv,Ti}

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

См. halfperm!

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

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

julia> A = X * X';

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

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

julia> l, u = C; # destructuring via iteration

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), задающей порядок (вместо по умолчанию используемой в CHOLMOD перестановки AMD).

Примеры

В следующем примере используемая перестановка, сокращающая заполнение, равна [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.

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

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

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)

Обновить разложение Холецкого или LLt F матрицы A на разложение матрицы A + C*C'.

Разложения Холецкого конвертируются в 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.

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

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

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)

Обновить разложение Холецкого или LLt F матрицы A на разложение матрицы A - C*C'.

Разложения Холецкого конвертируются в LDLt.

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

lowrankupdowndate!(F::CHOLMOD.Factor, C::Sparse, update::Cint)

Обновить разложение Холецкого или LLt F матрицы A на разложение матрицы A ± C*C'.

Если используется разложение, сохраняющее разреженность, т.е. L*L' == P*A*P', то новый фактор будет L*L' == P*A*P' + C'*C.

update: Cint(1) для A + CC', Cint(0) для A - CC'

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

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

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

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

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

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

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

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # read Julia default configuration for a Float64 sparse matrix
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optional - display values
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # reenable iterative refinement (2 is UMFPACK default max iterative refinement steps)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # solve Ax = b, including UMFPACK iterative refinement

Отдельные компоненты факторизации 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 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); # destructuring via iteration

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

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} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

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

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

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

\[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 factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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