Разреженные массивы

Julia поддерживает разреженные векторы и разреженные матрицы в модуле SparseArrays stdlib. Разреженные массивы — это массивы, содержащие достаточно нулей, что хранение их в специальной структуре данных приводит к экономии места и времени выполнения по сравнению с плотно заполненными массивами.

Хранение разреженной матрицы в формате Compressed Sparse Column (CSC)

В Julia разреженные матрицы хранятся в формате Compressed Sparse Column (CSC). Разреженные матрицы Julia имеют тип SparseMatrixCSC{Tv,Ti}, где Tv — тип хранимых значений, а Ti — целочисленный тип для хранения указателей на столбцы и индексов строк. Внутреннее представление SparseMatrixCSC таково:

struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrixCSC{Tv,Ti}
    m::Int                  # Number of rows
    n::Int                  # Number of columns
    colptr::Vector{Ti}      # Column j is in colptr[j]:(colptr[j+1]-1)
    rowval::Vector{Ti}      # Row indices of stored values
    nzval::Vector{Tv}       # Stored values, typically nonzeros
end

Хранение в формате Compressed Sparse Column (CSC) обеспечивает лёгкий и быстрый доступ к элементам в столбце разреженной матрицы, в то время как доступ к разреженной матрице по строкам значительно медленнее. Операции, такие как вставка ранее не хранимых элементов по одному в структуру CSC, обычно медленные. Это связано с тем, что все элементы разреженной матрицы, находящиеся за точкой вставки, должны быть сдвинуты на одну позицию.

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

Если у вас есть данные в формате CSC из другого приложения или библиотеки и вы хотите импортировать их в Julia, убедитесь, что вы используете индексирование с началом с 1. Индексы строк в каждом столбце должны быть отсортированы. Если ваш SparseMatrixCSC объект содержит не отсортированные индексы строк, быстрый способ отсортировать их — выполнить двойное транспонирование.

В некоторых приложениях удобно хранить явные нулевые значения в SparseMatrixCSC. Эти значения принимаются функциями в Base (но нет гарантии, что они сохранятся при изменяющих операциях). Такие явно хранимые нули обрабатываются многими процедурами как структурные ненулевые элементы. Функция nnz возвращает количество элементов, явно хранимых в структуре разреженных данных, включая неструктурные нули. Чтобы посчитать точное количество ненулевых числовых элементов, используйте count(!iszero, x), которая проверяет каждый хранимый элемент разреженной матрицы. dropzeros и встроенная dropzeros! могут использоваться для удаления хранимых нулей из разреженной матрицы.

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

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

Хранение разреженных векторов

Разреженные векторы хранятся в аналоге сжатого столбца (Compressed Sparse Column) для разреженных матриц. В Julia разреженные векторы имеют тип SparseVector{Tv,Ti}, где Tv — тип хранимых значений, а Ti — целочисленный тип для индексов. Внутреннее представление таково:

struct SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
    n::Int              # Length of the sparse vector
    nzind::Vector{Ti}   # Indices of stored values
    nzval::Vector{Tv}   # Stored values, typically nonzeros
end

Как и для SparseMatrixCSC, тип SparseVector также может содержать явно хранимые нули. (См. Хранение разреженных матриц.)

Конструкторы разреженных векторов и матриц

Самый простой способ создать разреженный массив — использовать функцию, эквивалентную функции zeros, которую предоставляет Julia для работы с плотно заполненными массивами. Чтобы получить разреженный массив вместо этого, можно использовать то же имя с префиксом sp:

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

Функция sparse часто является удобным способом создания разреженных массивов. Например, для создания разреженной матрицы мы можем ввести вектор I индексов строк, вектор J индексов столбцов и вектор V хранимых значений (это также известно как формат COO (координат)). sparse(I,J,V) затем создаёт разреженную матрицу, такую что S[I[k], J[k]] = V[k]. Эквивалентный конструктор разреженного вектора — sparsevec, который принимает вектор индексов (строк) I и вектор V с хранимыми значениями и создаёт разреженный вектор R такой, что R[I[k]] = V[k].

julia> I = [1, 4, 3, 5]; J = [4, 7, 18, 9]; V = [1, 2, -5, 3];

julia> S = sparse(I,J,V)
5×18 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
⠀⠈⠀⡀⠀⠀⠀⠀⠠
⠀⠀⠀⠀⠁⠀⠀⠀⠀

julia> R = sparsevec(I,V)
5-element SparseVector{Int64, Int64} with 4 stored entries:
  [1]  =  1
  [3]  =  -5
  [4]  =  2
  [5]  =  3

Обратная функция к sparse и sparsevec — findnz, которая извлекает входные данные, используемые для создания разреженного массива. findall(!iszero, x) возвращает декартовы индексы ненулевых элементов в x (включая хранимые нулевые элементы).

julia> findnz(S)
([1, 4, 5, 3], [4, 7, 9, 18], [1, 2, 3, -5])

julia> findall(!iszero, S)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 4)
 CartesianIndex(4, 7)
 CartesianIndex(5, 9)
 CartesianIndex(3, 18)

julia> findnz(R)
([1, 3, 4, 5], [1, -5, 2, 3])

julia> findall(!iszero, R)
4-element Vector{Int64}:
 1
 3
 4
 5

Другой способ создать разреженный массив — преобразовать плотный массив в разреженный массив, используя функцию sparse:

julia> sparse(Matrix(1.0I, 5, 5))
5×5 SparseMatrixCSC{Float64, Int64} with 5 stored entries:
 1.0   ⋅    ⋅    ⋅    ⋅
  ⋅   1.0   ⋅    ⋅    ⋅
  ⋅    ⋅   1.0   ⋅    ⋅
  ⋅    ⋅    ⋅   1.0   ⋅
  ⋅    ⋅    ⋅    ⋅   1.0

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

Вы можете выполнить обратное преобразование с помощью конструктора Array. Функция issparse может использоваться для проверки, является ли матрица разреженной.

julia> issparse(spzeros(5))
true

Операции с разреженными матрицами

Арифметические операции с разреженными матрицами также работают так же, как и с плотными матрицами. Индексирование, присваивание и конкатенация разреженных матриц работают так же, как и с плотными матрицами. Операции индексирования, особенно присваивания, являются дорогостоящими, если выполняются по одному элементу за раз. Во многих случаях может быть лучше преобразовать разреженную матрицу в формат (I,J,V) с помощью findnz, манипулировать значениями или структурой в плотных векторах (I,J,V), а затем восстановить разреженную матрицу.

Соответствие плотных и разреженных методов

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

Подробности можно найти в разделе «Разреженные векторы и матрицы» справки стандартной библиотеки.

Разреженная	Плотная	Описание
`spzeros(m,n)`	`zeros(m,n)`	Создаёт m-на-n матрицу нулей. (`spzeros(m,n)` пуста.)
`sparse(I,n,n)`	`Matrix(I,n,n)`	Создаёт n-на-n единичную матрицу.
`sparse(A)`	`Array(S)`	Преобразует между плотными и разреженными форматами.
`sprand(m,n,d)`	`rand(m,n)`	Создаёт m-на-n случайную матрицу (плотности d) с независимыми и одинаково распределёнными ненулевыми элементами, равномерно распределёнными на полуоткрытом интервале $[0, 1)$.
`sprandn(m,n,d)`	`randn(m,n)`	Создаёт m-на-n случайную матрицу (плотности d) с независимыми и одинаково распределёнными ненулевыми элементами, распределёнными по стандартному нормальному (гауссову) распределению.
`sprandn(rng,m,n,d)`	`randn(rng,m,n)`	Создаёт m-на-n случайную матрицу (плотности d) с независимыми и одинаково распределёнными ненулевыми элементами, сгенерированными с помощью `rng` генератора случайных чисел.

Разреженные массивы

`SparseArrays.AbstractSparseArray`Тип

AbstractSparseArray{Tv,Ti,N}

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

`SparseArrays.AbstractSparseVector`Тип

AbstractSparseVector{Tv,Ti}

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

`SparseArrays.AbstractSparseMatrix`Тип

AbstractSparseMatrix{Tv,Ti}

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

`SparseArrays.SparseVector`Тип

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

Тип вектора для хранения разреженных векторов.

`SparseArrays.SparseMatrixCSC`Тип

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

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

`SparseArrays.sparse`Функция

sparse(A)

Преобразовать абстрактную матрицу 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

`SparseArrays.sparsevec`Функция

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

`SparseArrays.issparse`Функция

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

`SparseArrays.nnz`Функция

nnz(A)

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

Примеры

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

julia> nnz(A)
3

`SparseArrays.findnz`Функция

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

`SparseArrays.spzeros`Функция

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

`SparseArrays.spdiagm`Функция

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

Примеры

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

`SparseArrays.sparse_hcat`Функция

sparse_hcat(A...)

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

Этот метод был добавлен в Julia 1.8. Он имитирует предыдущее поведение конкатенации, где конкатенация со специализированными типами матриц «разреженных» из LinearAlgebra.jl автоматически давала разреженный результат даже при отсутствии аргумента SparseArray.

`SparseArrays.sparse_vcat`Функция

sparse_vcat(A...)

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

`SparseArrays.sparse_hvcat`Функция

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

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

`SparseArrays.blockdiag`Функция

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

`SparseArrays.sprand`Функция

sprand([rng],[type],m,[n],p::AbstractFloat,[rfn])

Создать случайный разреженный вектор длины m или разреженную m на n матрицу, в которой вероятность того, что любой элемент ненулевой, независимо задаётся p (и, следовательно, средняя плотность ненулевых элементов также равна точно p). Ненулевые значения выбираются из распределения, указанного в rfn, и имеют тип type. При отсутствии указания используется равномерное распределение. Необязательный аргумент 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

`SparseArrays.sprandn`Функция

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

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

Для указания типа элементов результата Type требуется по крайней мере Julia 1.1.

Примеры

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

`SparseArrays.nonzeros`Функция

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

`SparseArrays.rowvals`Функция

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

`SparseArrays.nzrange`Функция

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

`SparseArrays.droptol!`Функция

droptol!(A::AbstractSparseMatrixCSC, tol)

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

droptol!(x::SparseVector, tol)

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

`SparseArrays.dropzeros!`Функция

dropzeros!(A::AbstractSparseMatrixCSC;)

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

Для варианта без изменения исходного объекта, см. dropzeros. Для получения алгоритмической информации, см. fkeep!.

dropzeros!(x::SparseVector)

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

Для варианта без изменения исходного объекта, см. dropzeros. Для получения алгоритмической информации, см. fkeep!.

`SparseArrays.dropzeros`Функция

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::SparseVector)

Генерирует копию 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

`SparseArrays.permute`Функция

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

`Base.permute!`Метод

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.

© 2009–2022 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
https://docs.julialang.org/en/v1.8/stdlib/SparseArrays/

Разреженные массивы

Хранение разреженной матрицы в формате Compressed Sparse Column (CSC)

Хранение разреженных векторов

Конструкторы разреженных векторов и матриц

Операции с разреженными матрицами

Соответствие плотных и разреженных методов

Разреженные массивы

SparseArrays.AbstractSparseArrayТип

SparseArrays.AbstractSparseVectorТип

SparseArrays.AbstractSparseMatrixТип

SparseArrays.SparseVectorТип

SparseArrays.SparseMatrixCSCТип

SparseArrays.sparseФункция

SparseArrays.sparsevecФункция

SparseArrays.issparseФункция

SparseArrays.nnzФункция

SparseArrays.findnzФункция

SparseArrays.spzerosФункция

SparseArrays.spdiagmФункция

SparseArrays.sparse_hcatФункция

SparseArrays.sparse_vcatФункция

SparseArrays.sparse_hvcatФункция

SparseArrays.blockdiagФункция

SparseArrays.sprandФункция

SparseArrays.sprandnФункция

SparseArrays.nonzerosФункция

SparseArrays.rowvalsФункция

SparseArrays.nzrangeФункция

SparseArrays.droptol!Функция

SparseArrays.dropzeros!Функция

SparseArrays.dropzerosФункция

SparseArrays.permuteФункция

Base.permute!Метод

`SparseArrays.AbstractSparseArray`Тип

`SparseArrays.AbstractSparseVector`Тип

`SparseArrays.AbstractSparseMatrix`Тип

`SparseArrays.SparseVector`Тип

`SparseArrays.SparseMatrixCSC`Тип

`SparseArrays.sparse`Функция

`SparseArrays.sparsevec`Функция

`SparseArrays.issparse`Функция

`SparseArrays.nnz`Функция

`SparseArrays.findnz`Функция

`SparseArrays.spzeros`Функция

`SparseArrays.spdiagm`Функция

`SparseArrays.sparse_hcat`Функция

`SparseArrays.sparse_vcat`Функция

`SparseArrays.sparse_hvcat`Функция

`SparseArrays.blockdiag`Функция

`SparseArrays.sprand`Функция

`SparseArrays.sprandn`Функция

`SparseArrays.nonzeros`Функция

`SparseArrays.rowvals`Функция

`SparseArrays.nzrange`Функция

`SparseArrays.droptol!`Функция

`SparseArrays.dropzeros!`Функция

`SparseArrays.dropzeros`Функция

`SparseArrays.permute`Функция

`Base.permute!`Метод