New design for handling unstored values

Author: mtfishman

Project.toml

@@ -1,7 +1,7 @@
 name = "SparseArraysBase"
 uuid = "0d5efcca-f356-4864-8770-e1ed8d78f208"
 authors = ["ITensor developers <[email protected]> and contributors"]
-version = "0.6.0"
+version = "0.7.0"
 
 [deps]
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"

docs/Project.toml

@@ -8,4 +8,4 @@ SparseArraysBase = "0d5efcca-f356-4864-8770-e1ed8d78f208"
 Dictionaries = "0.4.4"
 Documenter = "1.8.1"
 Literate = "2.20.1"
-SparseArraysBase = "0.6.0"
+SparseArraysBase = "0.7.0"

examples/Project.toml

@@ -5,5 +5,5 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 Dictionaries = "0.4.4"
-SparseArraysBase = "0.6.0"
+SparseArraysBase = "0.7.0"
 Test = "<0.0.1, 1"

src/abstractsparsearray.jl

@@ -20,12 +20,33 @@ using DerivableInterfaces: @derive
 using ArrayLayouts: ArrayLayouts
 using LinearAlgebra: LinearAlgebra
 
-# DerivableInterfaces `Base.getindex`, `Base.setindex!`, etc.
-# TODO: Define `AbstractMatrixOps` and overload for
-# `AnyAbstractSparseMatrix` and `AnyAbstractSparseVector`,
-# which is where matrix multiplication and factorizations
-# should go.
-@derive AnyAbstractSparseArray AbstractArrayOps
+@derive (T=AnyAbstractSparseArray,) begin
+  Base.getindex(::T, ::Any...)
+  Base.getindex(::T, ::Int...)
+  Base.setindex!(::T, ::Any, ::Any...)
+  Base.setindex!(::T, ::Any, ::Int...)
+  Base.similar(::T, ::Type, ::Tuple{Vararg{Int}})
+  Base.similar(::T, ::Type, ::Tuple{Base.OneTo,Vararg{Base.OneTo}})
+  Base.copy(::T)
+  Base.copy!(::AbstractArray, ::T)
+  Base.copyto!(::AbstractArray, ::T)
+  Base.map(::Any, ::T...)
+  Base.map!(::Any, ::AbstractArray, ::T...)
+  Base.mapreduce(::Any, ::Any, ::T...; kwargs...)
+  Base.reduce(::Any, ::T...; kwargs...)
+  Base.all(::Function, ::T)
+  Base.all(::T)
+  Base.iszero(::T)
+  Base.real(::T)
+  Base.fill!(::T, ::Any)
+  DerivableInterfaces.zero!(::T)
+  Base.zero(::T)
+  Base.permutedims!(::Any, ::T, ::Any)
+  Broadcast.BroadcastStyle(::Type{<:T})
+  Base.copyto!(::T, ::Broadcast.Broadcasted{Broadcast.DefaultArrayStyle{0}})
+  ArrayLayouts.MemoryLayout(::Type{<:T})
+  LinearAlgebra.mul!(::AbstractMatrix, ::T, ::T, ::Number, ::Number)
+end
 
 using DerivableInterfaces.Concatenate: concatenate
 # We overload `Base._cat` instead of `Base.cat` since it
@@ -75,27 +96,30 @@ from the input indices.
 This constructor does not take ownership of the supplied storage, and will result in an
 independent container.
 """
-sparse(::Union{AbstractDict,AbstractDictionary}, dims...; kwargs...)
+sparse(::Union{AbstractDict,AbstractDictionary}, dims...)
 
 const AbstractDictOrDictionary = Union{AbstractDict,AbstractDictionary}
 # checked constructor from data: use `setindex!` to validate/convert input
-function sparse(storage::AbstractDictOrDictionary, dims::Dims; kwargs...)
-  A = SparseArrayDOK{valtype(storage)}(undef, dims; kwargs...)
+function sparse(storage::AbstractDictOrDictionary, unstored::AbstractArray)
+  A = SparseArrayDOK(Unstored(unstored))
   for (i, v) in pairs(storage)
     A[i] = v
   end
   return A
 end
-function sparse(storage::AbstractDictOrDictionary, dims::Int...; kwargs...)
-  return sparse(storage, dims; kwargs...)
+function sparse(storage::AbstractDictOrDictionary, ax::Tuple)
+  return sparse(storage, Zeros{valtype(storage)}(ax))
+end
+function sparse(storage::AbstractDictOrDictionary, dims::Int...)
+  return sparse(storage, dims)
 end
 # Determine the size automatically.
-function sparse(storage::AbstractDictOrDictionary; kwargs...)
+function sparse(storage::AbstractDictOrDictionary)
   dims = ntuple(Returns(0), length(keytype(storage)))
   for I in keys(storage)
     dims = map(max, dims, Tuple(I))
   end
-  return sparse(storage, dims; kwargs...)
+  return sparse(storage, dims)
 end
 
 using Random: Random, AbstractRNG, default_rng
@@ -107,12 +131,18 @@ Create an empty size `dims` sparse array.
 The optional `T` argument specifies the element type, which defaults to `Float64`.
 """ sparsezeros
 
-function sparsezeros(::Type{T}, dims::Dims; kwargs...) where {T}
-  return SparseArrayDOK{T}(undef, dims; kwargs...)
+function sparsezeros(::Type{T}, unstored::AbstractArray{<:Any,N}) where {T,N}
+  return SparseArrayDOK{T,N}(Unstored(unstored))
+end
+function sparsezeros(unstored::AbstractArray{T,N}) where {T,N}
+  return SparseArrayDOK{T,N}(Unstored(unstored))
+end
+function sparsezeros(::Type{T}, dims::Dims) where {T}
+  return sparsezeros(T, Zeros{T}(dims))
 end
-sparsezeros(::Type{T}, dims::Int...; kwargs...) where {T} = sparsezeros(T, dims; kwargs...)
-sparsezeros(dims::Dims; kwargs...) = sparsezeros(Float64, dims; kwargs...)
-sparsezeros(dims::Int...; kwargs...) = sparsezeros(Float64, dims; kwargs...)
+sparsezeros(::Type{T}, dims::Int...) where {T} = sparsezeros(T, dims)
+sparsezeros(dims::Dims) = sparsezeros(Float64, dims)
+sparsezeros(dims::Int...) = sparsezeros(Float64, dims)
 
 @doc """
     sparserand([rng], [T::Type], dims; density::Real=0.5, randfun::Function=rand) -> A::SparseArrayDOK{T}

src/abstractsparsearrayinterface.jl

@@ -1,7 +1,9 @@
 using Base: @_propagate_inbounds_meta
 using DerivableInterfaces:
   DerivableInterfaces, @derive, @interface, AbstractArrayInterface, zero!
+using FillArrays: Zeros
 
+function unstored end
 function eachstoredindex end
 function getstoredindex end
 function getunstoredindex end
@@ -12,9 +14,27 @@ function storedlength end
 function storedpairs end
 function storedvalues end
 
-# Replace the function for accessing
-# unstored values.
-function set_getunstoredindex end
+# Indicates that the array should be interpreted
+# as the unstored values of a sparse array.
+struct Unstored{T,N,P<:AbstractArray{T,N}} <: AbstractArray{T,N}
+  parent::P
+end
+Base.parent(a::Unstored) = a.parent
+
+unstored(a::AbstractArray) = Zeros{eltype(a)}(axes(a))
+
+function unstoredsimilar(a::AbstractArray, T::Type, ax::Tuple)
+  return Zeros{T}(ax)
+end
+function unstoredsimilar(a::AbstractArray, T::Type)
+  return unstoredsimilar(a, T, axes(a))
+end
+function unstoredsimilar(a::AbstractArray, ax::Tuple)
+  return unstoredsimilar(a, eltype(a), ax)
+end
+function unstoredsimilar(a::AbstractArray)
+  return unstoredsimilar(a, eltype(a), axes(a))
+end
 
 # Generic functionality for converting to a
 # dense array, trying to preserve information
@@ -84,13 +104,22 @@ Base.size(a::StoredValues) = size(a.storedindices)
   return setindex!(a.array, value, a.storedindices[I])
 end
 
-# TODO: This may need to be defined in `sparsearraydok.jl`, after `SparseArrayDOK`
-# is defined. And/or define `default_type(::SparseArrayStyle, T::Type) = SparseArrayDOK{T}`.
 @interface ::AbstractSparseArrayInterface function Base.similar(
-  a::AbstractArray, T::Type, size::Tuple{Vararg{Int}}
+  a::AbstractArray, T::Type, ax::Tuple
 )
-  # TODO: Define `default_similartype` or something like that?
-  return SparseArrayDOK{T}(undef, size)
+  return SparseArrayDOK(Unstored(unstoredsimilar(unstored(a), T, ax)))
+end
+# Fix ambiguity error with DerivableInterfaces.jl.
+@interface ::AbstractSparseArrayInterface function Base.similar(
+  a::AbstractArray, T::Type, ax::Tuple{Int,Vararg{Int}}
+)
+  return SparseArrayDOK(Unstored(unstoredsimilar(unstored(a), T, ax)))
+end
+# Fix ambiguity error with DerivableInterfaces.jl.
+@interface ::AbstractSparseArrayInterface function Base.similar(
+  a::AbstractArray, T::Type, ax::Tuple{Base.OneTo,Vararg{Base.OneTo}}
+)
+  return SparseArrayDOK(Unstored(unstoredsimilar(unstored(a), T, ax)))
 end
 using DerivableInterfaces: DerivableInterfaces, zero!
 
@@ -136,7 +165,10 @@ end
 
 abstract type AbstractSparseArrayStyle{N} <: Broadcast.AbstractArrayStyle{N} end
 
-@derive AbstractSparseArrayStyle AbstractArrayStyleOps
+@derive (T=AbstractSparseArrayStyle,) begin
+  Base.similar(::Broadcast.Broadcasted{<:T}, ::Type, ::Tuple)
+  Base.copyto!(::AbstractArray, ::Broadcast.Broadcasted{<:T})
+end
 
 struct SparseArrayStyle{N} <: AbstractSparseArrayStyle{N} end