[SparseArraysBase] Rename SparseArrayInterface to SparseArraysBase (#1591)

mtfishman · web-flow · commit 82b050f0ec60 · 2024-11-15T19:23:57.000-05:00
diff --git a/ext/BlockSparseArraysGradedAxesExt/test/runtests.jl b/ext/BlockSparseArraysGradedAxesExt/test/runtests.jl
@@ -13,7 +13,7 @@ using NDTensors.GradedAxes:
   gradedrange,
   isdual
 using NDTensors.LabelledNumbers: label
-using NDTensors.SparseArrayInterface: stored_length
+using NDTensors.SparseArraysBase: stored_length
 using NDTensors.SymmetrySectors: U1
 using NDTensors.TensorAlgebra: fusedims, splitdims
 using LinearAlgebra: adjoint
diff --git a/ext/BlockSparseArraysTensorAlgebraExt/test/runtests.jl b/ext/BlockSparseArraysTensorAlgebraExt/test/runtests.jl
@@ -2,7 +2,7 @@
 using Test: @test, @testset
 using NDTensors.BlockSparseArrays: BlockSparseArray
 using NDTensors.TensorAlgebra: contract
-using NDTensors.SparseArrayInterface: densearray
+using NDTensors.SparseArraysBase: densearray
 @testset "BlockSparseArraysTensorAlgebraExt (eltype=$elt)" for elt in (
   Float32, Float64, Complex{Float32}, Complex{Float64}
 )
diff --git a/src/BlockArraysExtensions/BlockArraysExtensions.jl b/src/BlockArraysExtensions/BlockArraysExtensions.jl
@@ -22,7 +22,7 @@ using BlockArrays:
 using Compat: allequal
 using Dictionaries: Dictionary, Indices
 using ..GradedAxes: blockedunitrange_getindices, to_blockindices
-using ..SparseArrayInterface: SparseArrayInterface, stored_length, stored_indices
+using ..SparseArraysBase: SparseArraysBase, stored_length, stored_indices
 
 # A return type for `blocks(array)` when `array` isn't blocked.
 # Represents a vector with just that single block.
@@ -534,7 +534,7 @@ function Base.setindex!(a::BlockView{<:Any,N}, value, index::Vararg{Int,N}) wher
   return a
 end
 
-function SparseArrayInterface.stored_length(a::BlockView)
+function SparseArraysBase.stored_length(a::BlockView)
   # TODO: Store whether or not the block is stored already as
   # a Bool in `BlockView`.
   I = CartesianIndex(Int.(a.block))
diff --git a/src/BlockArraysSparseArraysBaseExt/BlockArraysSparseArraysBaseExt.jl b/src/BlockArraysSparseArraysBaseExt/BlockArraysSparseArraysBaseExt.jl
@@ -1,11 +1,11 @@
 using BlockArrays: AbstractBlockArray, BlocksView
-using ..SparseArrayInterface: SparseArrayInterface, stored_length
+using ..SparseArraysBase: SparseArraysBase, stored_length
 
-function SparseArrayInterface.stored_length(a::AbstractBlockArray)
+function SparseArraysBase.stored_length(a::AbstractBlockArray)
   return sum(b -> stored_length(b), blocks(a); init=zero(Int))
 end
 
 # TODO: Handle `BlocksView` wrapping a sparse array?
-function SparseArrayInterface.storage_indices(a::BlocksView)
+function SparseArraysBase.storage_indices(a::BlocksView)
   return CartesianIndices(a)
 end
diff --git a/src/BlockSparseArrays.jl b/src/BlockSparseArrays.jl
@@ -21,7 +21,7 @@ include("abstractblocksparsearray/linearalgebra.jl")
 include("abstractblocksparsearray/cat.jl")
 include("blocksparsearray/defaults.jl")
 include("blocksparsearray/blocksparsearray.jl")
-include("BlockArraysSparseArrayInterfaceExt/BlockArraysSparseArrayInterfaceExt.jl")
+include("BlockArraysSparseArraysBaseExt/BlockArraysSparseArraysBaseExt.jl")
 include("../ext/BlockSparseArraysTensorAlgebraExt/src/BlockSparseArraysTensorAlgebraExt.jl")
 include("../ext/BlockSparseArraysGradedAxesExt/src/BlockSparseArraysGradedAxesExt.jl")
 include("../ext/BlockSparseArraysAdaptExt/src/BlockSparseArraysAdaptExt.jl")
diff --git a/src/abstractblocksparsearray/abstractblocksparsearray.jl b/src/abstractblocksparsearray/abstractblocksparsearray.jl
@@ -1,6 +1,6 @@
 using BlockArrays:
   BlockArrays, AbstractBlockArray, Block, BlockIndex, BlockedUnitRange, blocks
-using ..SparseArrayInterface: sparse_getindex, sparse_setindex!
+using ..SparseArraysBase: sparse_getindex, sparse_setindex!
 
 # TODO: Delete this. This function was replaced
 # by `stored_length` but is still used in `NDTensors`.
diff --git a/src/abstractblocksparsearray/arraylayouts.jl b/src/abstractblocksparsearray/arraylayouts.jl
@@ -1,6 +1,6 @@
 using ArrayLayouts: ArrayLayouts, DualLayout, MemoryLayout, MulAdd
 using BlockArrays: BlockLayout
-using ..SparseArrayInterface: SparseLayout
+using ..SparseArraysBase: SparseLayout
 using ..TypeParameterAccessors: parenttype, similartype
 
 function ArrayLayouts.MemoryLayout(arraytype::Type{<:AnyAbstractBlockSparseArray})
diff --git a/src/abstractblocksparsearray/map.jl b/src/abstractblocksparsearray/map.jl
@@ -1,8 +1,8 @@
 using ArrayLayouts: LayoutArray
 using BlockArrays: blockisequal
 using LinearAlgebra: Adjoint, Transpose
-using ..SparseArrayInterface:
-  SparseArrayInterface,
+using ..SparseArraysBase:
+  SparseArraysBase,
   SparseArrayStyle,
   sparse_map!,
   sparse_copy!,
@@ -62,7 +62,7 @@ end
 # is used to determine `union_stored_blocked_cartesianindices(...)`).
 # `reblock` is a partial solution to that, but a bit ad-hoc.
 # TODO: Move to `blocksparsearrayinterface/map.jl`.
-function SparseArrayInterface.sparse_map!(
+function SparseArraysBase.sparse_map!(
   ::BlockSparseArrayStyle, f, a_dest::AbstractArray, a_srcs::Vararg{AbstractArray}
 )
   a_dest, a_srcs = reblock(a_dest), reblock.(a_srcs)
@@ -89,7 +89,7 @@ function SparseArrayInterface.sparse_map!(
 end
 
 # TODO: Implement this.
-# function SparseArrayInterface.sparse_mapreduce(::BlockSparseArrayStyle, f, a_dest::AbstractArray, a_srcs::Vararg{AbstractArray})
+# function SparseArraysBase.sparse_mapreduce(::BlockSparseArrayStyle, f, a_dest::AbstractArray, a_srcs::Vararg{AbstractArray})
 # end
 
 function Base.map!(f, a_dest::AbstractArray, a_srcs::Vararg{AnyAbstractBlockSparseArray})
diff --git a/src/abstractblocksparsearray/sparsearrayinterface.jl b/src/abstractblocksparsearray/sparsearrayinterface.jl
@@ -1,5 +1,5 @@
 using BlockArrays: Block
-using ..SparseArrayInterface: SparseArrayInterface, sparse_storage, stored_indices
+using ..SparseArraysBase: SparseArraysBase, sparse_storage, stored_indices
 
 # Structure storing the block sparse storage
 struct BlockSparseStorage{Arr<:AbstractBlockSparseArray}
@@ -29,10 +29,10 @@ function Base.iterate(s::BlockSparseStorage, args...)
   return iterate(values(s), args...)
 end
 
-function SparseArrayInterface.sparse_storage(a::AbstractBlockSparseArray)
+function SparseArraysBase.sparse_storage(a::AbstractBlockSparseArray)
   return BlockSparseStorage(a)
 end
 
-function SparseArrayInterface.stored_length(a::AnyAbstractBlockSparseArray)
+function SparseArraysBase.stored_length(a::AnyAbstractBlockSparseArray)
   return sum(stored_length, sparse_storage(blocks(a)); init=zero(Int))
 end
diff --git a/src/blocksparsearrayinterface/arraylayouts.jl b/src/blocksparsearrayinterface/arraylayouts.jl
@@ -1,6 +1,6 @@
 using ArrayLayouts: ArrayLayouts, Dot, MatMulMatAdd, MatMulVecAdd, MulAdd
 using BlockArrays: BlockLayout
-using ..SparseArrayInterface: SparseLayout
+using ..SparseArraysBase: SparseLayout
 using LinearAlgebra: dot, mul!
 
 function blocksparse_muladd!(
diff --git a/src/blocksparsearrayinterface/blocksparsearrayinterface.jl b/src/blocksparsearrayinterface/blocksparsearrayinterface.jl
@@ -13,7 +13,7 @@ using BlockArrays:
   blocks,
   findblockindex
 using LinearAlgebra: Adjoint, Transpose
-using ..SparseArrayInterface: perm, iperm, stored_length, sparse_zero!
+using ..SparseArraysBase: perm, iperm, stored_length, sparse_zero!
 
 blocksparse_blocks(a::AbstractArray) = error("Not implemented")
 
@@ -142,8 +142,7 @@ end
 
 # BlockArrays
 
-using ..SparseArrayInterface:
-  SparseArrayInterface, AbstractSparseArray, AbstractSparseMatrix
+using ..SparseArraysBase: SparseArraysBase, AbstractSparseArray, AbstractSparseMatrix
 
 _perm(::PermutedDimsArray{<:Any,<:Any,perm}) where {perm} = perm
 _invperm(::PermutedDimsArray{<:Any,<:Any,<:Any,invperm}) where {invperm} = invperm
@@ -170,16 +169,16 @@ function Base.getindex(
     blocks(parent(a.array))[_getindices(index, _invperm(a.array))...], _perm(a.array)
   )
 end
-function SparseArrayInterface.stored_indices(a::SparsePermutedDimsArrayBlocks)
+function SparseArraysBase.stored_indices(a::SparsePermutedDimsArrayBlocks)
   return map(I -> _getindices(I, _perm(a.array)), stored_indices(blocks(parent(a.array))))
 end
 # TODO: Either make this the generic interface or define
-# `SparseArrayInterface.sparse_storage`, which is used
+# `SparseArraysBase.sparse_storage`, which is used
 # to defined this.
-function SparseArrayInterface.stored_length(a::SparsePermutedDimsArrayBlocks)
+function SparseArraysBase.stored_length(a::SparsePermutedDimsArrayBlocks)
   return length(stored_indices(a))
 end
-function SparseArrayInterface.sparse_storage(a::SparsePermutedDimsArrayBlocks)
+function SparseArraysBase.sparse_storage(a::SparsePermutedDimsArrayBlocks)
   return error("Not implemented")
 end
 
@@ -241,22 +240,22 @@ function Base.isassigned(a::SparseSubArrayBlocks{<:Any,N}, I::Vararg{Int,N}) whe
   # TODO: Implement this properly.
   return true
 end
-function SparseArrayInterface.stored_indices(a::SparseSubArrayBlocks)
+function SparseArraysBase.stored_indices(a::SparseSubArrayBlocks)
   return stored_indices(view(blocks(parent(a.array)), blockrange(a)...))
 end
 # TODO: Either make this the generic interface or define
-# `SparseArrayInterface.sparse_storage`, which is used
+# `SparseArraysBase.sparse_storage`, which is used
 # to defined this.
-SparseArrayInterface.stored_length(a::SparseSubArrayBlocks) = length(stored_indices(a))
+SparseArraysBase.stored_length(a::SparseSubArrayBlocks) = length(stored_indices(a))
 
 ## struct SparseSubArrayBlocksStorage{Array<:SparseSubArrayBlocks}
 ##   array::Array
 ## end
-function SparseArrayInterface.sparse_storage(a::SparseSubArrayBlocks)
+function SparseArraysBase.sparse_storage(a::SparseSubArrayBlocks)
   return map(I -> a[I], stored_indices(a))
 end
 
-function SparseArrayInterface.getindex_zero_function(a::SparseSubArrayBlocks)
+function SparseArraysBase.getindex_zero_function(a::SparseSubArrayBlocks)
   # TODO: Base it off of `getindex_zero_function(blocks(parent(a.array))`, but replace the
   # axes with `axes(a.array)`.
   return BlockZero(axes(a.array))
@@ -272,4 +271,4 @@ function blocksparse_blocks(
 end
 
 using BlockArrays: BlocksView
-SparseArrayInterface.stored_length(a::BlocksView) = length(a)
+SparseArraysBase.stored_length(a::BlocksView) = length(a)
diff --git a/src/blocksparsearrayinterface/cat.jl b/src/blocksparsearrayinterface/cat.jl
@@ -1,9 +1,9 @@
 using BlockArrays: AbstractBlockedUnitRange, blockedrange, blocklengths
-using NDTensors.SparseArrayInterface: SparseArrayInterface, allocate_cat_output, sparse_cat!
+using NDTensors.SparseArraysBase: SparseArraysBase, allocate_cat_output, sparse_cat!
 
-# TODO: Maybe move to `SparseArrayInterfaceBlockArraysExt`.
-# TODO: Handle dual graded unit ranges, for example in a new `SparseArrayInterfaceGradedAxesExt`.
-function SparseArrayInterface.axis_cat(
+# TODO: Maybe move to `SparseArraysBaseBlockArraysExt`.
+# TODO: Handle dual graded unit ranges, for example in a new `SparseArraysBaseGradedAxesExt`.
+function SparseArraysBase.axis_cat(
   a1::AbstractBlockedUnitRange, a2::AbstractBlockedUnitRange
 )
   return blockedrange(vcat(blocklengths(a1), blocklengths(a2)))
diff --git a/test/test_basics.jl b/test/test_basics.jl
@@ -30,7 +30,7 @@ using NDTensors.BlockSparseArrays:
   blocktype,
   view!
 using NDTensors.GPUArraysCoreExtensions: cpu
-using NDTensors.SparseArrayInterface: stored_length
+using NDTensors.SparseArraysBase: stored_length
 using NDTensors.SparseArrayDOKs: SparseArrayDOK, SparseMatrixDOK, SparseVectorDOK
 using NDTensors.TensorAlgebra: contract
 using Test: @test, @test_broken, @test_throws, @testset, @inferred

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`using Test: @test, @testset`
`3`	`3`	`using NDTensors.BlockSparseArrays: BlockSparseArray`
`4`	`4`	`using NDTensors.TensorAlgebra: contract`
`5`		`-using NDTensors.SparseArrayInterface: densearray`
	`5`	`+using NDTensors.SparseArraysBase: densearray`
`6`	`6`	`@testset "BlockSparseArraysTensorAlgebraExt (eltype=$elt)" for elt in (`
`7`	`7`	`Float32, Float64, Complex{Float32}, Complex{Float64}`
`8`	`8`	`)`