Merge branch 'master' into mf/blockrange_struct_constructor

Author: dlfivefifty

src/blockbroadcast.jl

@@ -15,10 +15,15 @@ BlockStyle(::Val{N}) where {N} = BlockStyle{N}()
 BlockedStyle(::Val{N}) where {N} = BlockedStyle{N}()
 BlockStyle{M}(::Val{N}) where {N,M} = BlockStyle{N}()
 BlockedStyle{M}(::Val{N}) where {N,M} = BlockedStyle{N}()
-BroadcastStyle(::Type{<:BlockArray{<:Any,N}}) where {N} = BlockStyle{N}()
-BroadcastStyle(::Type{<:BlockedArray{<:Any,N}}) where {N} = BlockedStyle{N}()
-BroadcastStyle(::Type{<:AdjOrTrans{<:Any,<:BlockArray{<:Any,N}}}) where {N} = BlockStyle{2}()
-BroadcastStyle(::Type{<:AdjOrTrans{<:Any,<:BlockedArray{<:Any,N}}}) where {N} = BlockedStyle{2}()
+blockbroadcaststyle(::AbstractArrayStyle{N}) where {N} = BlockStyle{N}()
+blockedbroadcaststyle(::AbstractArrayStyle{N}) where {N} = BlockedStyle{N}()
+
+BroadcastStyle(::Type{<:BlockArray{<:Any,N,Blocks}}) where {N,Blocks} = blockbroadcaststyle(BroadcastStyle(Blocks))
+BroadcastStyle(::Type{<:BlockedArray{<:Any,N,Blocks}}) where {N,Blocks} = blockedbroadcaststyle(BroadcastStyle(Blocks))
+BroadcastStyle(::Type{<:Adjoint{T,<:BlockArray{<:Any,N,Blocks}}}) where {T,N,Blocks} = blockbroadcaststyle(BroadcastStyle(Adjoint{T,Blocks}))
+BroadcastStyle(::Type{<:Transpose{T,<:BlockArray{<:Any,N,Blocks}}}) where {T,N,Blocks} = blockbroadcaststyle(BroadcastStyle(Transpose{T,Blocks}))
+BroadcastStyle(::Type{<:Adjoint{T,<:BlockedArray{<:Any,N,Blocks}}}) where {T,N,Blocks} = blockedbroadcaststyle(BroadcastStyle(Adjoint{T,Blocks}))
+BroadcastStyle(::Type{<:Transpose{T,<:BlockedArray{<:Any,N,Blocks}}}) where {T,N,Blocks} = blockedbroadcaststyle(BroadcastStyle(Transpose{T,Blocks}))
 
 BroadcastStyle(::DefaultArrayStyle{N}, b::AbstractBlockStyle{M}) where {M,N} = typeof(b)(Val(max(M,N)))
 BroadcastStyle(a::AbstractBlockStyle{N}, ::DefaultArrayStyle{M}) where {M,N} = typeof(a)(Val(max(M,N)))
@@ -271,3 +276,13 @@ for op in (:*, :\)
         broadcasted(::AbstractBlockStyle, ::typeof($op), a::AbstractArray{T}, b::Ones{V}) where {T,V} = LinearAlgebra.copy_oftype(a, Base.promote_op(*, T, V))
     end
 end
+
+
+
+###
+# Ranges
+###
+
+broadcasted(::DefaultArrayStyle{1}, ::typeof(+), r::AbstractBlockedUnitRange, x::Integer) = _BlockedUnitRange(first(r) + x, blocklasts(r) .+ x)
+broadcasted(::DefaultArrayStyle{1}, ::typeof(+), x::Integer, r::AbstractBlockedUnitRange) = _BlockedUnitRange(x + first(r), x .+ blocklasts(r))
+broadcasted(::DefaultArrayStyle{1}, ::typeof(-), r::AbstractBlockedUnitRange, x::Integer) = _BlockedUnitRange(first(r) - x, blocklasts(r) .- x)

src/blockindices.jl

@@ -211,7 +211,8 @@ getindex(B::Block{N}, inds::Vararg{AbstractUnitRange{<:Integer},N}) where N = Bl
 getindex(B::Block{1}, inds::Colon) = B
 getindex(B::Block{1}, inds::Base.Slice) = B
 
-@propagate_inbounds getindex(B::BlockIndexRange{1}, kr::AbstractUnitRange{<:Integer}) = BlockIndexRange(B.block, B.indices[1][kr])
+getindex(B::BlockIndexRange{0}) = B.block[]
+@propagate_inbounds getindex(B::BlockIndexRange{N}, kr::Vararg{AbstractUnitRange{<:Integer},N}) where {N} = BlockIndexRange(B.block, map(getindex, B.indices, kr))
 @propagate_inbounds getindex(B::BlockIndexRange{N}, inds::Vararg{Int,N}) where N = B.block[Base.reindex(B.indices, inds)...]
 
 eltype(R::BlockIndexRange) = eltype(typeof(R))
@@ -290,6 +291,27 @@ _indices(B) = B
 
 Block(bs::BlockSlice{<:BlockIndexRange}) = Block(bs.block)
 
+"""
+    BlockedSlice(blocks, indices)
+
+Represents blocked indices attached to a collection of corresponding blocks.
+
+Upon calling `to_indices()`, a collection of blocks are converted to BlockedSlice objects to represent
+the indices over which the blocks span.
+
+This mimics the relationship between `Colon` and `Base.Slice`, `Block` and `BlockSlice`, etc.
+"""
+struct BlockedSlice{BB,T<:Integer,INDS<:AbstractVector{T}} <: AbstractVector{T}
+    blocks::BB
+    indices::INDS
+end
+
+for f in (:axes, :size)
+    @eval $f(S::BlockedSlice) = $f(S.indices)
+end
+
+@propagate_inbounds getindex(S::BlockedSlice, i::Integer) = getindex(S.indices, i)
+@propagate_inbounds getindex(S::BlockedSlice, k::Block{1}) = BlockSlice(S.blocks[Int(k)], getindex(S.indices, k))
 
 struct BlockRange{N,R<:NTuple{N,AbstractUnitRange{<:Integer}}} <: AbstractArray{Block{N,Int},N}
     indices::R

src/blocks.jl

@@ -7,7 +7,7 @@ Return the array-of-arrays view to `a` such that
 blocks(a)[i₁, i₂, ..., iₙ] == a[Block(i₁), Block(i₂), ..., Block(iₙ)]
 ```
 
-This function does not copy the blocks and give a mutable viwe to the original
+This function does not copy the blocks and give a mutable view to the original
 array.  This is an "inverse" of [`mortar`](@ref).
 
 # Examples

src/views.jl

@@ -11,7 +11,7 @@ function unblock(A, inds, I)
 end
 
 _blockslice(B, a::AbstractUnitRange) = BlockSlice(B, a)
-_blockslice(B, a) = a # drop block structure
+_blockslice(B, a) = BlockedSlice(B, a)
 
 # Allow `ones(2)[Block(1)[1:1], Block(1)[1:1]]` which is
 # similar to `ones(2)[1:1, 1:1]`.
@@ -150,10 +150,11 @@ block(A::Block) = A
 @inline view(block_arr::AbstractBlockArray{<:Any,N}, blocks::Vararg{BlockSlice1, N}) where N =
     view(block_arr, map(block,blocks)...)
 
-const BlockSlices = Union{Base.Slice,BlockSlice{<:BlockRange{1}}}
+const BlockSlices = Union{Base.Slice,BlockSlice{<:BlockRange{1}},BlockedSlice}
 # view(V::SubArray{<:Any,N,NTuple{N,BlockSlices}},
 
 _block_reindex(b::BlockSlice, i::Block{1}) = b.block[Int(i)]
+_block_reindex(b::BlockedSlice, i::Block{1}) = b.blocks[Int(i)]
 _block_reindex(b::Slice, i::Block{1}) = i
 
 @inline view(V::SubArray{<:Any,N,<:AbstractBlockArray,<:NTuple{N,BlockSlices}}, block::Block{N}) where N =

test/test_blockbroadcast.jl

@@ -193,6 +193,24 @@ using StaticArrays
         @test blockisequal(axes(A .* Ones(axes(A))), axes(Ones(axes(A)) .* A), axes(A .* ones(6)))
     end
 
+    @testset "Blocked unit range broadcast" begin
+        r = blockedrange([2,3])
+        @test r .+ 3 == blockedrange(4, [2,3])
+        @test blocklengths(r .+ 3) == [2,3]
+        @test 3 .+ r == blockedrange(4, [2,3])
+        @test blocklengths(3 .+ r .+ 3) == [2,3]
+        @test r .- 3 == blockedrange(-2, [2,3])
+        @test blocklengths(r .- 3) == [2,3]
+
+        r = blockedrange(2, [2,3])
+        @test r .+ 3 == blockedrange(5, [2,3])
+        @test blocklengths(r .+ 3) == [2,3]
+        @test 3 .+ r == blockedrange(5, [2,3])
+        @test blocklengths(3 .+ r .+ 3) == [2,3]
+        @test r .- 3 == blockedrange(-1, [2,3])
+        @test blocklengths(r .- 3) == [2,3]
+    end
+
     @testset "type inference" begin
         u = BlockArray(randn(5), [2,3]);
         A = zeros(size(u))

test/test_blockindices.jl

@@ -2,7 +2,7 @@ module TestBlockIndices
 
 using BlockArrays, FillArrays, Test, StaticArrays, ArrayLayouts
 using OffsetArrays
-import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice
+import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice, BlockedSlice
 
 @testset "Blocks" begin
     @test Int(Block(2)) === Integer(Block(2)) === Number(Block(2)) === 2
@@ -90,6 +90,8 @@ import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice
         @test Block(1,1)[1,1] == BlockIndex((1,1),(1,1)) == BlockIndex((1,1),(1,))
         @test Block(1,1)[1:2,1:2] == BlockIndexRange(Block(1,1),(1:2,1:2))
         @test Block(1)[1:3][1:2] == BlockIndexRange(Block(1),1:2)
+        @test Block(1,1)[2:4,2:4][2:3,2:3] == BlockIndexRange(Block(1,1),(3:4,3:4))
+        @test BlockIndexRange(Block(),())[] == BlockIndex()
         @test BlockIndex((2,2,2),(2,)) == BlockIndex((2,2,2),(2,1,)) == BlockIndex((2,2,2),(2,1,1))
         @test BlockIndex(2,(2,)) === BlockIndex((2,),(2,))
         @test BlockIndex(UInt(2),(2,)) === BlockIndex((UInt(2),),(2,))
@@ -835,6 +837,16 @@ end
     end
 end
 
+@testset "BlockedSlice" begin
+    b = BlockedSlice([Block(2), Block(1)], mortar([3:5, 1:2]))
+    @test length(b) == 5
+    for i in eachindex(b.indices)
+        @test b[i] === b.indices[i]
+    end
+    @test b[Block(1)] === BlockSlice(Block(2), 3:5)
+    @test b[Block(2)] === BlockSlice(Block(1), 1:2)
+end
+
 #=
 [1,1  1,2] | [1,3  1,4  1,5]
 --------------------------

test/test_blockrange.jl

@@ -29,6 +29,15 @@ using BlockArrays, Test
     @test view(A, Block.(1:2)) == [1,2,3]
     @test A[Block.(1:2)] == [1,2,3]
 
+    V = view(A, [Block(3), Block(2)])
+    @test V == [4, 5, 6, 2, 3]
+    I = parentindices(V)[1]
+    @test I isa BlockArrays.BlockedSlice{<:Vector{<:Block{1}}}
+    @test V[Block(1)] == 4:6
+    @test V[Block(2)] == 2:3
+    @test view(V, Block(1)) === view(A, Block(3))
+    @test view(V, Block(2)) === view(A, Block(2))
+
     A = BlockArray(reshape(collect(1:(6*12)),6,12), 1:3, 3:5)
 
     @test view(A, Block.(1:2), Block.(1:2)) == A[1:3,1:7]