Require undef in BlockSparseArray constructors

Project.toml

@@ -1,7 +1,7 @@
 name = "BlockSparseArrays"
 uuid = "2c9a651f-6452-4ace-a6ac-809f4280fbb4"
 authors = ["ITensor developers <[email protected]> and contributors"]
-version = "0.2.28"
+version = "0.3.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

README.md

@@ -35,7 +35,7 @@ julia> Pkg.add("BlockSparseArrays")
 
 ````julia
 using BlockArrays: BlockArrays, BlockedVector, Block, blockedrange
-using BlockSparseArrays: BlockSparseArray, blockstoredlength
+using BlockSparseArrays: BlockSparseArray, blockstoredlength, sparsemortar
 using Test: @test, @test_broken
 
 function main()
@@ -60,13 +60,13 @@ function main()
     reshape(@view(d_data[Block(i)]), block_size(i_axes, nz_blocks[i])) for
     i in 1:length(nz_blocks)
   ]
-  b = BlockSparseArray(nz_blocks, d_blocks, i_axes)
+  b = sparsemortar(nz_blocks, d_blocks, i_axes)
 
   @test blockstoredlength(b) == 2
 
   # Blocks with discontiguous underlying data
   d_blocks = randn.(nz_block_sizes)
-  b = BlockSparseArray(nz_blocks, d_blocks, i_axes)
+  b = sparsemortar(nz_blocks, d_blocks, i_axes)
 
   @test blockstoredlength(b) == 2
 
@@ -114,7 +114,7 @@ using BlockSparseArrays: BlockSparseArray
 
 i1 = [2, 3]
 i2 = [2, 3]
-B = BlockSparseArray{Float64}(i1, i2)
+B = BlockSparseArray{Float64}(undef, i1, i2)
 B[Block(1, 1)] = randn(2, 2)
 B[Block(2, 2)] = randn(3, 3)
 

docs/Project.toml

@@ -6,6 +6,6 @@ Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306"
 
 [compat]
 BlockArrays = "1"
-BlockSparseArrays = "0.2"
+BlockSparseArrays = "0.3"
 Documenter = "1"
 Literate = "2"

examples/Project.toml

@@ -5,5 +5,5 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 BlockArrays = "1"
-BlockSparseArrays = "0.2"
+BlockSparseArrays = "0.3"
 Test = "1"

examples/README.jl

@@ -40,7 +40,7 @@ julia> Pkg.add("BlockSparseArrays")
 # ## Examples
 
 using BlockArrays: BlockArrays, BlockedVector, Block, blockedrange
-using BlockSparseArrays: BlockSparseArray, blockstoredlength
+using BlockSparseArrays: BlockSparseArray, blockstoredlength, sparsemortar
 using Test: @test, @test_broken
 
 function main()
@@ -65,13 +65,13 @@ function main()
     reshape(@view(d_data[Block(i)]), block_size(i_axes, nz_blocks[i])) for
     i in 1:length(nz_blocks)
   ]
-  b = BlockSparseArray(nz_blocks, d_blocks, i_axes)
+  b = sparsemortar(nz_blocks, d_blocks, i_axes)
 
   @test blockstoredlength(b) == 2
 
   ## Blocks with discontiguous underlying data
   d_blocks = randn.(nz_block_sizes)
-  b = BlockSparseArray(nz_blocks, d_blocks, i_axes)
+  b = sparsemortar(nz_blocks, d_blocks, i_axes)
 
   @test blockstoredlength(b) == 2
 
@@ -117,7 +117,7 @@ using BlockSparseArrays: BlockSparseArray
 
 i1 = [2, 3]
 i2 = [2, 3]
-B = BlockSparseArray{Float64}(i1, i2)
+B = BlockSparseArray{Float64}(undef, i1, i2)
 B[Block(1, 1)] = randn(2, 2)
 B[Block(2, 2)] = randn(3, 3)
 

ext/BlockSparseArraysGradedUnitRangesExt/BlockSparseArraysGradedUnitRangesExt.jl

@@ -17,7 +17,7 @@ function similar_blocksparse(
   return BlockSparseArray{
     elt,length(axes),similartype(unwrap_array_type(blocktype(a)), elt, axes)
   }(
-    axes
+    undef, axes
   )
 end
 

src/BlockSparseArrays.jl

@@ -5,7 +5,8 @@ export BlockSparseArray,
   BlockSparseVector,
   blockstoredlength,
   eachblockstoredindex,
-  eachstoredblock
+  eachstoredblock,
+  sparsemortar
 
 # factorizations
 include("factorizations/svd.jl")

src/abstractblocksparsearray/arraylayouts.jl

@@ -38,7 +38,7 @@
   # TODO: Define `blocktype`/`blockstype` for `SubArray` wrapping `BlockSparseArray`.
   # TODO: Use `similar`?
   blocktype_a = blocktype(parent(a))
-  a_dest = BlockSparseArray{eltype(a),length(axes),blocktype_a}(axes)
+  a_dest = BlockSparseArray{eltype(a),length(axes),blocktype_a}(undef, axes)
   a_dest .= a
   return a_dest
 end

src/blocksparsearray/blocksparsearray.jl

@@ -3,9 +3,6 @@
 using Dictionaries: Dictionary
 using SparseArraysBase: SparseArrayDOK
 
-# TODO: Delete this.
-## using BlockArrays: blocks
-
 struct BlockSparseArray{
   T,
   N,
@@ -27,142 +24,140 @@
   T,1,A,Blocks,Axes
 }
 
-function BlockSparseArray(
+"""
+    sparsemortar(blocks::AbstractArray{<:AbstractArray{T,N},N}, axes) -> ::BlockSparseArray{T,N}
+
+Construct a block sparse array from a sparse array of arrays and specified blocked axes.
+The block sizes must be commensurate with the blocks of the axes.
+"""
+function sparsemortar(
+  blocks::AbstractArray{<:AbstractArray{T,N},N}, axes::Tuple{Vararg{AbstractUnitRange,N}}
+) where {T,N}
+  return BlockSparseArray{T,N,eltype(blocks),typeof(blocks),typeof(axes)}(blocks, axes)
+end
+
+"""
+    sparsemortar(blocks::Dictionary{<:Block{N},<:AbstractArray{T,N}}, axes) -> ::BlockSparseArray{T,N}
+
+Construct a block sparse array from a dictionary mapping the locations of the stored/nonzero
+blocks to the data of those blocks, along with a set of blocked axes.
+The block sizes must be commensurate with the blocks of the specified axes.
+"""
+function sparsemortar(
   block_data::Dictionary{<:Block{N},<:AbstractArray{<:Any,N}},
   axes::Tuple{Vararg{AbstractUnitRange,N}},
 ) where {N}
   blocks = default_blocks(block_data, axes)
-  return BlockSparseArray(blocks, axes)
+  return sparsemortar(blocks, axes)
 end
 
-function BlockSparseArray(
+"""
+    sparsemortar(block_indices::Vector{<:Block{N}}, block_data::Vector{<:AbstractArray{T,N}}, axes) -> ::BlockSparseArray{T,N}
+
+Construct a block sparse array from a list of locations of the stored/nonzero blocks,
+a corresponding list of the data of those blocks, along with a set of blocked axes.
+The block sizes must be commensurate with the blocks of the specified axes.
+"""
+function sparsemortar(
   block_indices::Vector{<:Block{N}},
   block_data::Vector{<:AbstractArray{<:Any,N}},
   axes::Tuple{Vararg{AbstractUnitRange,N}},
 ) where {N}
-  return BlockSparseArray(Dictionary(block_indices, block_data), axes)
+  return sparsemortar(Dictionary(block_indices, block_data), axes)
 end
 
-function BlockSparseArray{T,N,A,Blocks}(
-  blocks::AbstractArray{<:AbstractArray{T,N},N}, axes::Tuple{Vararg{AbstractUnitRange,N}}
-) where {T,N,A<:AbstractArray{T,N},Blocks<:AbstractArray{A,N}}
-  return BlockSparseArray{T,N,A,Blocks,typeof(axes)}(blocks, axes)
-end
+@doc """
+    BlockSparseArray{T}(undef, dims)
+    BlockSparseArray{T,N}(undef, dims)
+    BlockSparseArray{T,N,A}(undef, dims)
 
-function BlockSparseArray{T,N,A}(
-  blocks::AbstractArray{<:AbstractArray{T,N},N}, axes::Tuple{Vararg{AbstractUnitRange,N}}
-) where {T,N,A<:AbstractArray{T,N}}
-  return BlockSparseArray{T,N,A,typeof(blocks)}(blocks, axes)
-end
-
-function BlockSparseArray{T,N}(
-  blocks::AbstractArray{<:AbstractArray{T,N},N}, axes::Tuple{Vararg{AbstractUnitRange,N}}
-) where {T,N}
-  return BlockSparseArray{T,N,eltype(blocks),typeof(blocks),typeof(axes)}(blocks, axes)
-end
-
-function BlockSparseArray{T,N}(
-  block_data::Dictionary{Block{N,Int},<:AbstractArray{T,N}},
-  axes::Tuple{Vararg{AbstractUnitRange,N}},
-) where {T,N}
-  blocks = default_blocks(block_data, axes)
-  return BlockSparseArray{T,N}(blocks, axes)
-end
+Construct an uninitialized N-dimensional BlockSparseArray containing elements of type T. `dims` should be a list
+of block lengths in each dimension or a list of blocked ranges representing the axes.
+""" BlockSparseArray
 
 function BlockSparseArray{T,N,A}(
-  axes::Tuple{Vararg{AbstractUnitRange,N}}
+  ::UndefInitializer, axes::Tuple{Vararg{AbstractUnitRange,N}}
 ) where {T,N,A<:AbstractArray{T,N}}
   blocks = default_blocks(A, axes)
-  return BlockSparseArray{T,N,A}(blocks, axes)
+  return sparsemortar(blocks, axes)
 end
 
 function BlockSparseArray{T,N,A}(
-  axes::Vararg{AbstractUnitRange,N}
+  ::UndefInitializer, axes::Vararg{AbstractUnitRange,N}
 ) where {T,N,A<:AbstractArray{T,N}}
-  return BlockSparseArray{T,N,A}(axes)
+  return BlockSparseArray{T,N,A}(undef, axes)
 end
 
 function BlockSparseArray{T,N,A}(
-  dims::Tuple{Vararg{Vector{Int},N}}
+  ::UndefInitializer, dims::Tuple{Vararg{Vector{Int},N}}
 ) where {T,N,A<:AbstractArray{T,N}}
-  return BlockSparseArray{T,N,A}(blockedrange.(dims))
+  return BlockSparseArray{T,N,A}(undef, blockedrange.(dims))
 end
 
 # Fix ambiguity error.
-function BlockSparseArray{T,0,A}(axes::Tuple{}) where {T,A<:AbstractArray{T,0}}
+function BlockSparseArray{T,0,A}(
+  ::UndefInitializer, axes::Tuple{}
+) where {T,A<:AbstractArray{T,0}}
   blocks = default_blocks(A, axes)
-  return BlockSparseArray{T,0,A}(blocks, axes)
+  return sparsemortar(blocks, axes)
 end
 
 function BlockSparseArray{T,N,A}(
-  dims::Vararg{Vector{Int},N}
+  ::UndefInitializer, dims::Vararg{Vector{Int},N}
 ) where {T,N,A<:AbstractArray{T,N}}
-  return BlockSparseArray{T,N,A}(dims)
-end
-
-function BlockSparseArray{T,N}(axes::Tuple{Vararg{AbstractUnitRange,N}}) where {T,N}
-  return BlockSparseArray{T,N,default_arraytype(T, axes)}(axes)
-end
-
-function BlockSparseArray{T,N}(axes::Vararg{AbstractUnitRange,N}) where {T,N}
-  return BlockSparseArray{T,N}(axes)
-end
-
-function BlockSparseArray{T,0}(axes::Tuple{}) where {T}
-  return BlockSparseArray{T,0,default_arraytype(T, axes)}(axes)
+  return BlockSparseArray{T,N,A}(undef, dims)
 end
 
-function BlockSparseArray{T,N}(dims::Tuple{Vararg{Vector{Int},N}}) where {T,N}
-  return BlockSparseArray{T,N}(blockedrange.(dims))
-end
-
-function BlockSparseArray{T,N}(dims::Vararg{Vector{Int},N}) where {T,N}
-  return BlockSparseArray{T,N}(dims)
+function BlockSparseArray{T,N}(
+  ::UndefInitializer, axes::Tuple{Vararg{AbstractUnitRange,N}}
+) where {T,N}
+  return BlockSparseArray{T,N,default_arraytype(T, axes)}(undef, axes)
 end
 
-function BlockSparseArray{T}(dims::Tuple{Vararg{Vector{Int}}}) where {T}
-  return BlockSparseArray{T,length(dims)}(dims)
+function BlockSparseArray{T,N}(
+  ::UndefInitializer, axes::Vararg{AbstractUnitRange,N}
+) where {T,N}
+  return BlockSparseArray{T,N}(undef, axes)
 end
 
-function BlockSparseArray{T}(axes::Tuple{Vararg{AbstractUnitRange}}) where {T}
-  return BlockSparseArray{T,length(axes)}(axes)
+function BlockSparseArray{T,0}(::UndefInitializer, axes::Tuple{}) where {T}
+  return BlockSparseArray{T,0,default_arraytype(T, axes)}(undef, axes)
 end
 
-function BlockSparseArray{T}(axes::Tuple{}) where {T}
-  return BlockSparseArray{T,length(axes)}(axes)
+function BlockSparseArray{T,N}(
+  ::UndefInitializer, dims::Tuple{Vararg{Vector{Int},N}}
+) where {T,N}
+  return BlockSparseArray{T,N}(undef, blockedrange.(dims))
 end
 
-function BlockSparseArray{T}(dims::Vararg{Vector{Int}}) where {T}
-  return BlockSparseArray{T}(dims)
+function BlockSparseArray{T,N}(::UndefInitializer, dims::Vararg{Vector{Int},N}) where {T,N}
+  return BlockSparseArray{T,N}(undef, dims)
 end
 
-function BlockSparseArray{T}(axes::Vararg{AbstractUnitRange}) where {T}
-  return BlockSparseArray{T}(axes)
+function BlockSparseArray{T}(::UndefInitializer, dims::Tuple{Vararg{Vector{Int}}}) where {T}
+  return BlockSparseArray{T,length(dims)}(undef, dims)
 end
 
-function BlockSparseArray{T}() where {T}
-  return BlockSparseArray{T}(())
+function BlockSparseArray{T}(
+  ::UndefInitializer, axes::Tuple{Vararg{AbstractUnitRange}}
+) where {T}
+  return BlockSparseArray{T,length(axes)}(undef, axes)
 end
 
-# undef
-function BlockSparseArray{T,N,A,Blocks}(
-  ::UndefInitializer, args...
-) where {T,N,A<:AbstractArray{T,N},Blocks<:AbstractArray{A,N}}
-  return BlockSparseArray{T,N,A,Blocks}(args...)
+function BlockSparseArray{T}(::UndefInitializer, axes::Tuple{}) where {T}
+  return BlockSparseArray{T,length(axes)}(undef, axes)
 end
 
-function BlockSparseArray{T,N,A}(
-  ::UndefInitializer, args...
-) where {T,N,A<:AbstractArray{T,N}}
-  return BlockSparseArray{T,N,A}(args...)
+function BlockSparseArray{T}(::UndefInitializer, dims::Vararg{Vector{Int}}) where {T}
+  return BlockSparseArray{T}(undef, dims)
 end
 
-function BlockSparseArray{T,N}(::UndefInitializer, args...) where {T,N}
-  return BlockSparseArray{T,N}(args...)
+function BlockSparseArray{T}(::UndefInitializer, axes::Vararg{AbstractUnitRange}) where {T}
+  return BlockSparseArray{T}(undef, axes)
 end
 
-function BlockSparseArray{T}(::UndefInitializer, args...) where {T}
-  return BlockSparseArray{T}(args...)
+function BlockSparseArray{T}(::UndefInitializer) where {T}
+  return BlockSparseArray{T}(undef, ())
 end
 
 # Base `AbstractArray` interface

src/blocksparsearrayinterface/map.jl

@@ -112,5 +112,5 @@
   # since they can't necessarily by `Diagonal` if there are rectangular blocks.
   mapped_blocks = Dictionary{eltype(bs),eltype(ds)}(bs, ds)
   # TODO: Use `similartype(typeof(a), eltype(eltype(mapped_blocks)))(...)`.
-  return BlockSparseArray(mapped_blocks, axes(a))
+  return sparsemortar(mapped_blocks, axes(a))
 end

test/Project.toml

@@ -26,7 +26,7 @@ Adapt = "4"
 Aqua = "0.8"
 ArrayLayouts = "1"
 BlockArrays = "1"
-BlockSparseArrays = "0.2"
+BlockSparseArrays = "0.3"
 DiagonalArrays = "0.2"
 GPUArraysCore = "0.2"
 GradedUnitRanges = "0.1"