Dl/blockaxisfixes (#99)

* More PSeudoBlockArray constructors, remove unused copyto!

* Update Project.toml

* fix #98

* increase coverage

* fix tests

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.11"
+version = "0.11.1"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/blockarray.jl

@@ -417,20 +417,6 @@ Base.dataids(arr::BlockArray) = (dataids(arr.blocks)..., dataids(arr.axes)...)
     end
 end
 
-@generated function copyto!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
-    return quote
-        block_sizes = blocksizes(block_array)
-
-        @nloops $N i i->(1:nblocks(block_sizes, i)) begin
-            block_index = @ntuple $N i
-            indices = globalrange(block_sizes, block_index)
-            copyto!(getblock(block_array, block_index...), arr[indices...])
-        end
-
-        return block_array
-    end
-end
-
 function Base.fill!(block_array::BlockArray, v)
     for block in block_array.blocks
         fill!(block, v)

src/blockindices.jl

@@ -175,6 +175,10 @@ BlockIndexRange(block::Block{N}, inds::Vararg{AbstractUnitRange{Int},N}) where {
 
 getindex(B::Block{N}, inds::Vararg{Int,N}) where N = BlockIndex(B,inds)
 getindex(B::Block{N}, inds::Vararg{AbstractUnitRange{Int},N}) where N = BlockIndexRange(B,inds)
+getindex(B::Block{1}, inds::Colon) = B
+getindex(B::Block{1}, inds::Base.Slice) = B
+
+getindex(B::BlockIndexRange{1}, kr::AbstractUnitRange{Int}) = BlockIndexRange(B.block, B.indices[1][kr])
 
 eltype(R::BlockIndexRange) = eltype(typeof(R))
 eltype(::Type{BlockIndexRange{N}}) where {N} = BlockIndex{N}
@@ -250,6 +254,8 @@ for f in (:axes, :unsafe_indices, :axes1, :first, :last, :size, :length,
 end
 
 getindex(S::BlockSlice, i::Integer) = getindex(S.indices, i)
+getindex(S::BlockSlice{<:Block}, k::AbstractUnitRange{Int}) = BlockSlice(S.block[k],S.indices[k])
+getindex(S::BlockSlice{<:BlockIndexRange}, k::AbstractUnitRange{Int}) = BlockSlice(S.block[k],S.indices[k])
 show(io::IO, r::BlockSlice) = print(io, "BlockSlice(", r.block, ",", r.indices, ")")
 next(S::BlockSlice, s) = next(S.indices, s)
 done(S::BlockSlice, s) = done(S.indices, s)
@@ -285,8 +291,8 @@ BlockRange(inds::Vararg{AbstractUnitRange{Int},N}) where {N} =
 (:)(start::Block{1}, stop::Block{1}) = BlockRange((first(start.n):first(stop.n),))
 (:)(start::Block, stop::Block) = throw(ArgumentError("Use `BlockRange` to construct a cartesian range of blocks"))
 Base.BroadcastStyle(::Type{<:BlockRange{1}}) = DefaultArrayStyle{1}()
-broadcasted(::DefaultArrayStyle{1}, ::typeof(Block), r::AbstractUnitRange) = Block(first(r)):Block(last(r))
-broadcasted(::DefaultArrayStyle{1}, ::typeof(Int), block_range::BlockRange{1}) = first(block_range.indices)
+broadcasted(::DefaultArrayStyle{1}, ::Type{Block}, r::AbstractUnitRange) = Block(first(r)):Block(last(r))
+broadcasted(::DefaultArrayStyle{1}, ::Type{Int}, block_range::BlockRange{1}) = first(block_range.indices)
 
 
 # AbstractArray implementation

src/pseudo_blockarray.jl

@@ -55,6 +55,9 @@ const PseudoBlockVecOrMat{T} = Union{PseudoBlockMatrix{T}, PseudoBlockVector{T}}
 @inline PseudoBlockArray(blocks::R, baxes::BS) where {T,N,R<:AbstractArray{T,N},BS<:NTuple{N,AbstractUnitRange{Int}}} =
     PseudoBlockArray{T, N, R,BS}(blocks, baxes)
 
+@inline PseudoBlockArray(blocks::PseudoBlockArray, baxes::BS) where {N,BS<:NTuple{N,AbstractUnitRange{Int}}} =
+    PseudoBlockArray(blocks.blocks, baxes)
+
 PseudoBlockArray(blocks::AbstractArray{T, N}, block_sizes::Vararg{AbstractVector{Int}, N}) where {T, N} =
     PseudoBlockArray(blocks, map(blockedrange,block_sizes))
 
@@ -92,6 +95,10 @@ convert(::Type{PseudoBlockArray{T,N}}, A::PseudoBlockArray{T,N}) where {T,N} = A
 convert(::Type{PseudoBlockArray{T}}, A::PseudoBlockArray{T}) where {T} = A
 convert(::Type{PseudoBlockArray}, A::PseudoBlockArray) = A
 
+convert(::Type{PseudoBlockArray{T,N,R,BS}}, A::PseudoBlockArray) where {T,N,R,BS} = 
+    PseudoBlockArray{T,N,R,BS}(convert(R, A.blocks), convert(BS, A.axes))
+
+
 PseudoBlockArray{T, N}(A::AbstractArray{T2, N}) where {T,T2,N} =
     PseudoBlockArray(Array{T, N}(A), axes(A))
 PseudoBlockArray{T1}(A::AbstractArray{T2, N}) where {T1,T2,N} = PseudoBlockArray{T1, N}(A)

test/test_blockarrays.jl

@@ -301,6 +301,12 @@ end
     @test C ≈ A ≈ BlockArray(A)
     @test eltype(C) == Float32
 
+    Ã = PseudoBlockArray(rand(2,3), Fill(1,2), [2,1])
+    @test convert(typeof(A), Ã) == Ã
+    
+    @test PseudoBlockArray(A, axes(Ã)) isa typeof(Ã)
+    @test PseudoBlockArray(A, axes(Ã)) == A    
+
 
     A = BlockArray(rand(2,3), [1,1], [2,1])
     C = convert(PseudoBlockArray, A)

test/test_blockindices.jl

@@ -1,5 +1,5 @@
 using BlockArrays, FillArrays, OffsetArrays, Test, Base64
-import BlockArrays: BlockIndex, BlockIndexRange
+import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice
 
 @testset "Blocks" begin
     @test Int(Block(2)) === Integer(Block(2)) === Number(Block(2)) === 2
@@ -55,19 +55,25 @@ import BlockArrays: BlockIndex, BlockIndexRange
         @test_throws MethodError convert(Int, Block(2,1))
         @test convert(Tuple{Int,Int}, Block(2,1)) == (2,1)
         @test convert(Tuple{Float64,Int}, Block(2,1)) == (2.0,1)
+
+        @test Block(1)[:] ≡ Block(1)[Base.Slice(1:2)] ≡ Block(1)
     end
 
     @testset "BlockIndex" begin
         @test Block(1)[1] == BlockIndex((1,),(1,))
         @test Block(1)[1:2] == BlockIndexRange(Block(1),(1:2,))
         @test Block(1,1)[1,1] == BlockIndex((1,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)
     end
 
     @testset "BlockRange" begin
         @test Block.(2:5) isa BlockRange
         @test Block.(Base.OneTo(5)) isa BlockRange
         @test Block.(2:5) == [Block(2),Block(3),Block(4),Block(5)]
+        b = Block.(2:5)
+        @test Int.(b) === 2:5
+        @test Base.OneTo.(1:5) isa Vector{Base.OneTo{Int}} #98
     end
 end
 
@@ -229,6 +235,12 @@ end
     end  
 end
 
+@testset "BlockSlice" begin
+    b = BlockSlice(Block(5),1:3)
+    @test b[Base.Slice(1:3)] ≡ b
+    @test b[1:2] ≡ b[1:2][1:2] ≡ BlockSlice(Block(5)[1:2],1:2)
+end
+
 #=
 [1,1  1,2] | [1,3  1,4  1,5]
 --------------------------