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

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

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],[type],m,[n],p::AbstractFloat,[rfn])

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

Примеры

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 описанный в F. Gustavson, "Two fast algorithms for sparse matrices: multiplication and permuted transposition," 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!