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

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

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

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

struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
    m::Int                  # Number of rows
    n::Int                  # Number of columns
    colptr::Vector{Ti}      # Column i is in colptr[i]:(colptr[i+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, 2, 3], [1, 2, 3], [0, 2, 0])
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  0
  [2, 2]  =  2
  [3, 3]  =  0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Int64,Int64} with 1 stored entry:
  [2, 2]  =  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:
  [1,  4]  =  1
  [4,  7]  =  2
  [5,  9]  =  3
  [3, 18]  =  -5

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 Array{CartesianIndex{2},1}:
 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 Array{Int64,1}:
 1
 3
 4
 5

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

julia> sparse(Matrix(1.0I, 5, 5))
5×5 SparseMatrixCSC{Float64,Int64} with 5 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0
  [4, 4]  =  1.0
  [5, 5]  =  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 быть ненулевым.

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

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

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} <: AbstractSparseMatrix{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 Array{Float64,2}:
 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, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  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, 1]  =  1
  [2, 2]  =  2
  [3, 3]  =  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:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2

julia> nnz(A)
3

SparseArrays.findnzФункция

findnz(A)

Возвращает кортеж (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, 1]  =  1
  [1, 2]  =  2
  [3, 2]  =  4
  [2, 3]  =  3

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

Построить квадратную разреженную диагональную матрицу из Pair векторов и диагоналей. Вектор kv.second будет помещен на kv.first диагональ.

Примеры

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

SparseArrays.blockdiagФункция

blockdiag(A...)

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

Примеры

julia> blockdiag(sparse(2I, 3, 3), sparse(4I, 2, 2))
5×5 SparseMatrixCSC{Int64,Int64} with 5 stored entries:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2
  [4, 4]  =  4
  [5, 5]  =  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:
  [2, 2]  =  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 задаёт генератор случайных чисел, см. Случайные числа.

Примеры

julia> sprandn(2, 2, 0.75)
2×2 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 2]  =  0.586617
  [2, 2]  =  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:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2

julia> nonzeros(A)
3-element Array{Int64,1}:
 2
 2
 2

SparseArrays.rowvalsФункция

rowvals(A::SparseMatrixCSC)

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

Примеры

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

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

SparseArrays.nzrangeФункция

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

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

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

SparseArrays.droptol!Функция

droptol!(A::SparseMatrixCSC, tol; trim::Bool = true)

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

droptol!(x::SparseVector, tol; trim::Bool = true)

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

SparseArrays.dropzeros!Функция

dropzeros!(A::SparseMatrixCSC; trim::Bool = true)

Удаляет сохраненные нулевые числовые значения из A, необязательно обрезая избыточное пространство в A.rowval и A.nzval если trim равно true.

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

dropzeros!(x::SparseVector; trim::Bool = true)

Удаляет сохраненные нулевые числовые значения из x, необязательно обрезая избыточное пространство в x.nzind и x.nzval если trim равно true.

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

SparseArrays.dropzerosФункция

dropzeros(A::SparseMatrixCSC; trim::Bool = true)

Создает копию A и удаляет сохраненные нулевые числовые значения из этой копии, необязательно обрезая избыточное пространство в массивах rowval и nzval результата, если trim равно true.

Для варианта на месте и информации об алгоритме, см. 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, 1]  =  1.0
  [2, 2]  =  0.0
  [3, 3]  =  1.0

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

dropzeros(x::SparseVector; trim::Bool = true)

Создает копию x и удаляет числовые нули из этой копии, необязательно обрезая избыточное пространство в массивах nzind и nzval результата, если trim равно true.

Для варианта на месте и информации об алгоритме, см. 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::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
        q::AbstractVector{<:Integer}) where {Tv,Ti}

Взаимно пермутирует A, возвращая PAQ (A[p,q]). Длина пермутации столбцов q должна совпадать с количеством столбцов в A (length(q) == A.n). Длина пермутации строк p должна совпадать с количеством строк в A (length(p) == A.m).

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

Примеры

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

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

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

Base.permute!Метод

permute!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
         [C::SparseMatrixCSC{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::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
         q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti},
         [workcolptr::Vector{Ti}]]) where {Tv,Ti}

Размеры X должны совпадать с размерами A (X.m == A.m и X.n == A.n), и X должен иметь достаточно памяти для размещения всех выделенных элементов в A (length(X.rowval) >= nnz(A) и length(X.nzval) >= nnz(A)). Длина столбцовой перестановки q должна совпадать с числом столбцов A (length(q) == A.n). Длина строчной перестановки p должна совпадать с числом строк A (length(p) == A.m).

Размеры C должны совпадать с размерами transpose(A) (C.m == A.n и C.n == A.m), и C должен иметь достаточно памяти для размещения всех выделенных элементов в A (length(C.rowval) >= nnz(A) и length(C.nzval) >= nnz(A)).

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

См. также: permute.