Разреженные массивы
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 из другого приложения или библиотеки, и вы хотите импортировать их в 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}
Тип матрицы для хранения разреженных матриц в формате Compressed Sparse Column. Стандартный способ создания SparseMatrixCSC — через функцию sparse. См. также spzeros, spdiagm и sprand.
SparseArrays.sparseФункция
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
исходный код
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}...)
Создать разреженную диагональную матрицу из векторов и диагоналей. Каждый вектор 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.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. Распределение равномерного вида используется в случае, если rfn не указано. Опциональный аргумент rng задает генератор случайных чисел, см. Случайные числа.
Примеры
julia> sprand(Bool, 2, 2, 0.5)
2×2 SparseMatrixCSC{Bool, Int64} with 1 stored entry:
⋅ ⋅
⋅ 1
julia> sprand(Float64, 3, 0.75)
3-element SparseVector{Float64, Int64} with 1 stored entry:
[3] = 0.298614
исходный код
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 2 stored entries:
⋅ 0.586617
⋅ 0.297336
исходный код
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–2021 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
https://docs.julialang.org/en/v1.6.0/stdlib/SparseArrays/
