move functions

Author: lkdvos

src/abstractsparsearray.jl

@@ -53,3 +53,63 @@ function getunstoredindex(a::ReplacedUnstoredSparseArray, I::Int...)
 end
 eachstoredindex(a::ReplacedUnstoredSparseArray) = eachstoredindex(parent(a))
 @derive ReplacedUnstoredSparseArray AbstractArrayOps
+
+# Special-purpose constructors
+# ----------------------------
+using Random: Random, AbstractRNG, default_rng
+
+@doc """
+    spzeros([T::Type], dims) -> A::SparseArrayDOK{T}
+
+Create an empty size `dims` sparse array.
+The optional `T` argument specifies the element type, which defaults to `Float64`.
+""" spzeros
+
+spzeros(dims::Dims) = spzeros(Float64, dims)
+spzeros(::Type{T}, dims::Dims) where {T} = SparseArrayDOK{T}(undef, dims)
+
+@doc """
+    sprand([rng], [T::Type], dims; density::Real=0.5, rfn::Function=rand) -> A::SparseArrayDOK{T}
+
+Create a random size `dims` sparse array in which the probability of any element being stored is independently given by `density`.
+The optional `rng` argument specifies a random number generator, see also `Random`.
+The optional `T` argument specifies the element type, which defaults to `Float64`.
+The optional `rfn` argument can be used to control the type of random elements.
+
+See also [`sprand!`](@ref).
+""" sprand
+
+function sprand(::Type{T}, dims::Dims; kwargs...) where {T}
+  return sprand(default_rng(), T, dims; kwargs...)
+end
+sprand(dims::Dims; kwargs...) = sprand(default_rng(), Float64, dims; kwargs...)
+function sprand(rng::AbstractRNG, dims::Dims; kwargs...)
+  return sprand(rng, Float64, dims; kwargs...)
+end
+function sprand(rng::AbstractRNG, ::Type{T}, dims::Dims; kwargs...) where {T}
+  A = SparseArrayDOK{T}(undef, dims)
+  sprand!(rng, A; kwargs...)
+  return A
+end
+
+@doc """
+    sprand!([rng], A::AbstractArray; density::Real=0.5, rfn::Function=rand) -> A
+
+Overwrite part of an array with random entries, where the probability of overwriting is independently given by `density`.
+The optional `rng` argument specifies a random number generator, see also `Random`.
+The optional `rfn` argument can be used to control the type of random elements.
+
+See also [`sprand`](@ref).
+""" sprand!
+
+sprand!(A::AbstractArray; kwargs...) = sprand!(default_rng(), A; kwargs...)
+function sprand!(
+  rng::AbstractRNG, A::AbstractArray; density::Real=0.5, rfn::Function=Random.rand
+)
+  ArrayLayouts.zero!(A)
+  rand_inds = Random.randsubseq(rng, eachindex(A), density)
+  rand_entries = rfn(rng, eltype(A), length(rand_inds))
+  for (I, v) in zip(rand_inds, rand_entries)
+    A[I] = v
+  end
+end

src/abstractsparsearrayinterface.jl

@@ -3,7 +3,6 @@ using DerivableInterfaces: DerivableInterfaces, @derive, @interface, AbstractArr
 # This is to bring `ArrayLayouts.zero!` into the namespace
 # since it is considered part of the sparse array interface.
 using ArrayLayouts: zero!
-using Random: Random, AbstractRNG, default_rng
 
 function eachstoredindex end
 function getstoredindex end
@@ -33,62 +32,6 @@ function densearray(a::AbstractArray)
   return Array(a)
 end
 
-@doc """
-    spzeros([T::Type], dims) -> A::SparseArrayDOK{T}
-
-Create an empty size `dims` sparse array.
-The optional `T` argument specifies the element type, which defaults to `Float64`.
-""" spzeros
-
-spzeros(dims::Dims) = spzeros(Float64, dims)
-spzeros(::Type{T}, dims::Dims) where {T} = SparseArrayDOK{T}(undef, dims)
-
-@doc """
-    sprand([rng], [T::Type], dims; density::Real=0.5, rfn::Function=rand) -> A::SparseArrayDOK{T}
-
-Create a random size `dims` sparse array in which the probability of any element being stored is independently given by `density`.
-The optional `rng` argument specifies a random number generator, see also `Random`.
-The optional `T` argument specifies the element type, which defaults to `Float64`.
-The optional `rfn` argument can be used to control the type of random elements.
-
-See also [`sprand!`](@ref).
-""" sprand
-
-function sprand(::Type{T}, dims::Dims; kwargs...) where {T}
-  return sprand(default_rng(), T, dims; kwargs...)
-end
-sprand(dims::Dims; kwargs...) = sprand(default_rng(), Float64, dims; kwargs...)
-function sprand(rng::AbstractRNG, dims::Dims; kwargs...)
-  return sprand(rng, Float64, dims; kwargs...)
-end
-function sprand(rng::AbstractRNG, ::Type{T}, dims::Dims; kwargs...) where {T}
-  A = SparseArrayDOK{T}(undef, dims)
-  sprand!(rng, A; kwargs...)
-  return A
-end
-
-@doc """
-    sprand!([rng], A::AbstractArray; density::Real=0.5, rfn::Function=rand) -> A
-
-Overwrite part of an array with random entries, where the probability of overwriting is independently given by `density`.
-The optional `rng` argument specifies a random number generator, see also `Random`.
-The optional `rfn` argument can be used to control the type of random elements.
-
-See also [`sprand`](@ref).
-""" sprand!
-
-sprand!(A::AbstractArray; kwargs...) = sprand!(default_rng(), A; kwargs...)
-function sprand!(
-  rng::AbstractRNG, A::AbstractArray; density::Real=0.5, rfn::Function=Random.rand
-)
-  ArrayLayouts.zero!(A)
-  rand_inds = Random.randsubseq(rng, eachindex(A), density)
-  rand_entries = rfn(rng, eltype(A), length(rand_inds))
-  for (I, v) in zip(rand_inds, rand_entries)
-    A[I] = v
-  end
-end
-
 # Minimal interface for `SparseArrayInterface`.
 # Fallbacks for dense/non-sparse arrays.
 @interface ::AbstractArrayInterface isstored(a::AbstractArray, I::Int...) = true