Add more tests

Author: mtfishman

src/BlockArraysExtensions/BlockArraysExtensions.jl

@@ -68,12 +68,20 @@ for f in (:axes, :unsafe_indices, :axes1, :first, :last, :size, :length, :unsafe
 end
 Base.getindex(S::BlockIndices, i::Integer) = getindex(S.indices, i)
 
-function _blockslice(x, y::AbstractUnitRange{<:Integer})
+# Generalization of to `BlockArrays._blockslice`:
+# https://github.com/JuliaArrays/BlockArrays.jl/blob/v1.6.3/src/views.jl#L13-L14
+# Used by `BlockArrays.unblock`, which is used in `to_indices`
+# to convert relative blockwise slices to absolute slices, but in a way
+# that preserves the original relative blockwise slice information.
+# TODO: Ideally this would be handled in BlockArrays.jl
+# once slicing like `A[Block(1)[[1, 2]]]` is supported.
+function _blockslice(x, y::AbstractUnitRange)
   return BlockSlice(x, y)
 end
-function _blockslice(x, y::AbstractVector{<:Integer})
+function _blockslice(x, y::AbstractVector)
   return BlockIndices(x, y)
 end
+
 function Base.getindex(S::BlockIndices, i::BlockSlice{<:Block{1}})
   # TODO: Check that `i.indices` is consistent with `S.indices`.
   # It seems like this isn't handling the case where `i` is a

src/BlockArraysExtensions/blockedunitrange.jl

@@ -292,6 +292,24 @@ end
   return b[GenericBlockIndex(tuple(K, J...))]
 end
 
+# TODO: Delete this once `BlockArrays.BlockIndex` is generalized.
+@inline function Base.to_indices(
+  A, inds, I::Tuple{AbstractVector{<:GenericBlockIndex{1}},Vararg{Any}}
+)
+  return (unblock(A, inds, I), to_indices(A, _maybetail(inds), Base.tail(I))...)
+end
+
+# This is a specialization of `BlockArrays.unblock`:
+# https://github.com/JuliaArrays/BlockArrays.jl/blob/v1.6.3/src/views.jl#L8-L11
+# that is used in the `to_indices` logic for blockwise slicing in
+# BlockArrays.jl.
+# TODO: Ideally this would be defined in BlockArrays.jl once the slicing
+# there is made more generic.
+function BlockArrays.unblock(A, inds, I::Tuple{GenericBlockIndex{1},Vararg{Any}})
+  B = first(I)
+  return _blockslice(B, inds[1][B])
+end
+
 # Work around the fact that it is type piracy to define
 # `Base.getindex(a::Block, b...)`.
 _getindex(a::Block{N}, b::Vararg{Any,N}) where {N} = GenericBlockIndex(a, b)
@@ -357,6 +375,17 @@ function blockedunitrange_getindices(
   return mortar(map(b -> a[b], blocks(indices)))
 end
 
+# This is a specialization of `BlockArrays.unblock`:
+# https://github.com/JuliaArrays/BlockArrays.jl/blob/v1.6.3/src/views.jl#L8-L11
+# that is used in the `to_indices` logic for blockwise slicing in
+# BlockArrays.jl.
+# TODO: Ideally this would be defined in BlockArrays.jl once the slicing
+# there is made more generic.
+function BlockArrays.unblock(A, inds, I::Tuple{BlockIndexVector{1},Vararg{Any}})
+  B = first(I)
+  return _blockslice(B, inds[1][B])
+end
+
 function to_blockindices(a::AbstractBlockedUnitRange{<:Integer}, I::AbstractArray{Bool})
   I_blocks = blocks(BlockedVector(I, blocklengths(a)))
   I′_blocks = map(eachindex(I_blocks)) do b

test/test_genericblockindex.jl

@@ -1,6 +1,23 @@
 using BlockArrays:
-  Block, BlockIndex, BlockedArray, BlockedVector, block, blockedrange, blockindex, mortar
-using BlockSparseArrays: BlockSparseArrays, BlockIndexVector, GenericBlockIndex
+  Block,
+  BlockIndex,
+  BlockSlice,
+  BlockedArray,
+  BlockedVector,
+  block,
+  blockedrange,
+  blockindex,
+  mortar
+using BlockSparseArrays:
+  BlockSparseArrays,
+  BlockIndexVector,
+  BlockIndices,
+  GenericBlockIndex,
+  blocksparsezeros,
+  blockedunitrange_getindices,
+  to_block,
+  to_block_indices,
+  to_blockindexrange
 using Test: @test, @test_broken, @testset
 
 # blockrange
@@ -157,4 +174,111 @@ using Test: @test, @test_broken, @testset
   i = GenericBlockIndex(Block(2), 2)
   @test to_indices(a, (i, i)) == (4, 4)
   @test to_indices(a, axes(a), (i, i)) == (4, 4)
+
+  r = blockedrange([2, 3])
+  i = mortar([BlockIndexVector(Block(2), [1, 3]), BlockIndexVector(Block(1), [2])])
+  @test blockedunitrange_getindices(r, i) == mortar([[3, 5], [2]])
+
+  r = blockedrange([2, 3])
+  T = GenericBlockIndex{1,Tuple{Int},Tuple{Int}}
+  i = mortar([
+    BlockIndexVector{1,T}(Block(2), [1, 3]), BlockIndexVector{1,T}(Block(1), [2])
+  ])
+  @test blockedunitrange_getindices(r, i) == mortar([[3, 5], [2]])
+
+  # Internal functions.
+  @test to_block(Block(2)) === Block(2)
+  @test to_block(Block(2)[2:3]) === Block(2)
+  @test to_block(BlockIndexVector(Block(2), [1, 3])) === Block(2)
+  @test to_block_indices(Block(2)) === (:)
+  @test to_block_indices(Block(2)[2:3]) === 2:3
+  @test to_block_indices(BlockIndexVector(Block(2), [1, 3])) == [1, 3]
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  i = Block(2)[2:3]
+  @test to_indices(a, (i, i)) ===
+    to_indices(a, axes(a), (i, i)) ===
+    (BlockSlice(i, 4:5), BlockSlice(i, 4:5))
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  i = mortar([Block(2)[2:3], Block(1)[2:2]])
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(i, mortar([4:5, 2:2]))
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == i
+      @test Iⱼ.indices == mortar([4:5, 2:2])
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  i = BlockIndexVector(Block(2), [1, 3])
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(i, [3, 5])
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == i
+      @test Iⱼ.indices == [3, 5]
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  T = GenericBlockIndex{1,Tuple{Int},Tuple{Int}}
+  i = BlockIndexVector{1,T}(Block(2), [1, 3])
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(i, [3, 5])
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == i
+      @test Iⱼ.indices == [3, 5]
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  i = mortar([BlockIndexVector(Block(2), [1, 3]), BlockIndexVector(Block(1), [2])])
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(i, mortar([[3, 5], [2]]))
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == i
+      @test Iⱼ.indices == mortar([[3, 5], [2]])
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  i = [BlockIndexVector(Block(2), [1, 3]), BlockIndexVector(Block(1), [2])]
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(mortar(i), mortar([[3, 5], [2]]))
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == mortar(i)
+      @test Iⱼ.indices == mortar([[3, 5], [2]])
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  T = GenericBlockIndex{1,Tuple{Int},Tuple{Int}}
+  i = mortar([
+    BlockIndexVector{1,T}(Block(2), [1, 3]), BlockIndexVector{1,T}(Block(1), [2])
+  ])
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(i, mortar([[3, 5], [2]]))
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == i
+      @test Iⱼ.indices == mortar([[3, 5], [2]])
+    end
+  end
+
+  a = blocksparsezeros([2, 3], [2, 3])
+  T = GenericBlockIndex{1,Tuple{Int},Tuple{Int}}
+  i = [BlockIndexVector{1,T}(Block(2), [1, 3]), BlockIndexVector{1,T}(Block(1), [2])]
+  for I in (to_indices(a, (i, i)), to_indices(a, axes(a), (i, i)))
+    for Iⱼ in I
+      @test Iⱼ == BlockIndices(mortar(i), mortar([[3, 5], [2]]))
+      @test Iⱼ isa BlockIndices
+      @test Iⱼ.blocks == mortar(i)
+      @test Iⱼ.indices == mortar([[3, 5], [2]])
+    end
+  end
 end