Add AbstractArray conversion special cases (#208)

* Add AbstractArray conversion special cases

* Don't convert blocks to ints in blockcolstart/etc.

* Update blocklinalg.jl

* Add rtests

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.16.15"
+version = "0.16.16"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/BlockArrays.jl

@@ -30,6 +30,7 @@ import Base: @propagate_inbounds, Array, to_indices, to_index,
             BroadcastStyle, checkbounds, throw_boundserror, 
             ones, zeros, intersect, Slice, resize!
 using Base: ReshapedArray, dataids
+import Base: AbstractArray
 
 
 import Base: (:), IteratorSize, iterate, axes1, strides, isempty

src/blockindices.jl

@@ -92,7 +92,7 @@ Number(index::Block{1}) = index.n[1]
 
 # print
 Base.show(io::IO, B::Block{0,Int}) = print(io, "Block()")
-function Base.show(io::IO, B::Block{N,Int}) where N 
+function Base.show(io::IO, B::Block{N,Int}) where N
     print(io, "Block($(B.n[1])")
     for n in Base.tail(B.n)
         print(io, ", $n")
@@ -177,7 +177,7 @@ end
     checkbounds(Bool, B, blockindex(I)...)
 end
 
-checkbounds(::Type{Bool}, A::AbstractArray{<:Any,N}, I::AbstractVector{BlockIndex{N}}) where N = 
+checkbounds(::Type{Bool}, A::AbstractArray{<:Any,N}, I::AbstractVector{BlockIndex{N}}) where N =
     all(checkbounds.(Bool, Ref(A), I))
 
 struct BlockIndexRange{N,R<:NTuple{N,AbstractUnitRange{Int}}} <: AbstractArray{BlockIndex{N},N}
@@ -381,9 +381,9 @@ intersect(a::BlockRange{1}, b::BlockRange{1}) = BlockRange(intersect(a.indices[1
 
 # needed for scalar-like broadcasting
 
-BlockSlice{Block{1,BT},RT}(a::Base.OneTo) where {BT,RT<:AbstractUnitRange} = 
+BlockSlice{Block{1,BT},RT}(a::Base.OneTo) where {BT,RT<:AbstractUnitRange} =
     BlockSlice(Block(convert(BT, 1)), convert(RT, a))::BlockSlice{Block{1,BT},RT}
-BlockSlice{BlockRange{1,Tuple{BT}},RT}(a::Base.OneTo) where {BT<:AbstractUnitRange,RT<:AbstractUnitRange} = 
+BlockSlice{BlockRange{1,Tuple{BT}},RT}(a::Base.OneTo) where {BT<:AbstractUnitRange,RT<:AbstractUnitRange} =
     BlockSlice(BlockRange(convert(BT, Base.OneTo(1))), convert(RT, a))::BlockSlice{BlockRange{1,Tuple{BT}},RT}
-BlockSlice{BlockIndexRange{1,Tuple{BT}},RT}(a::Base.OneTo) where {BT<:AbstractUnitRange,RT<:AbstractUnitRange} = 
+BlockSlice{BlockIndexRange{1,Tuple{BT}},RT}(a::Base.OneTo) where {BT<:AbstractUnitRange,RT<:AbstractUnitRange} =
     BlockSlice(BlockIndexRange(Block(1), convert(BT, Base.OneTo(1))), convert(RT, a))::BlockSlice{BlockIndexRange{1,Tuple{BT}},RT}

src/blocklinalg.jl

@@ -22,11 +22,11 @@ blockcolstop(A...) = last(blockcolsupport(A...))
 blockrowstart(A...) = first(blockrowsupport(A...))
 blockrowstop(A...) = last(blockrowsupport(A...))
 
+
 for Func in (:blockcolstart, :blockcolstop, :blockrowstart, :blockrowstop)
-    @eval $Func(A, i::Block{1}) = $Func(A, Int(i))
+    @eval @deprecate $Func(A, i::Integer) $Func(A, Block(i))
 end
 
-
 abstract type AbstractBlockLayout <: MemoryLayout end
 struct BlockLayout{ArrLay,BlockLay} <: AbstractBlockLayout end
 
@@ -277,7 +277,7 @@ function _matchingblocks_triangular_mul!(::Val{'L'}, UNIT, A::AbstractMatrix{T},
         b_2 = view(b, Block(K))
         L̃ = _triangular_matrix(Val('L'), UNIT, view(A, Block(K,K)))
         materialize!(Lmul(L̃, b_2))
-        JR = blockrowstart(A,K):Block(K-1)
+        JR = blockrowstart(A,Block(K)):Block(K-1)
         if !isempty(JR)
             muladd!(one(T), view(A, Block(K), JR), view(b,JR), one(T), b_2)
         end
@@ -327,7 +327,7 @@ for UNIT in ('U', 'N')
                 materialize!(Ldiv(Ũ, b_2))
 
                 if K ≥ 2
-                    KR = blockcolstart(A, K):Block(K-1)
+                    KR = blockcolstart(A, Block(K)):Block(K-1)
                     V_12 = view(A, KR, Block(K))
                     b̃_1 = view(b, KR)
                     muladd!(-one(T), V_12, b_2, one(T), b̃_1)
@@ -361,7 +361,7 @@ for UNIT in ('U', 'N')
                 materialize!(Ldiv(L̃, b_2))
 
                 if K < N
-                    KR = Block(K+1):blockcolstop(A, K)
+                    KR = Block(K+1):blockcolstop(A, Block(K))
                     V_12 = view(A, KR, Block(K))
                     b̃_1 = view(b, KR)
                     muladd!(-one(T), V_12, b_2, one(T), b̃_1)

src/pseudo_blockarray.jl

@@ -122,6 +122,12 @@ 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))
 
+convert(::Type{AbstractArray{T,N}}, A::PseudoBlockArray{T,N}) where {T,N} = A
+convert(::Type{AbstractArray{V,N} where V}, A::PseudoBlockArray{T,N}) where {T,N} = A
+convert(::Type{AbstractArray{T}}, A::PseudoBlockArray{T}) where {T} = A
+convert(::Type{AbstractArray}, A::PseudoBlockArray) = A
+
+
 
 PseudoBlockArray{T, N}(A::AbstractArray{T2, N}) where {T,T2,N} =
     PseudoBlockArray(Array{T, N}(A), axes(A))
@@ -135,6 +141,9 @@ convert(::Type{PseudoBlockArray{T1}}, A::AbstractArray{T2, N}) where {T1,T2,N} =
 convert(::Type{PseudoBlockArray}, A::AbstractArray{T, N}) where {T,N} =
     convert(PseudoBlockArray{T, N}, A)
 
+AbstractArray{T}(A::PseudoBlockArray) where T = PseudoBlockArray(AbstractArray{T}(A.blocks), A.axes)
+AbstractArray{T,N}(A::PseudoBlockArray) where {T,N} = PseudoBlockArray(AbstractArray{T,N}(A.blocks), A.axes)
+
 copy(A::PseudoBlockArray) = PseudoBlockArray(copy(A.blocks), A.axes)
 
 ###########################

test/test_blockarrayinterface.jl

@@ -18,6 +18,8 @@ bview(a, b) = Base.invoke(view, Tuple{AbstractArray,Any}, a, b)
 
     A = randn(5, 5)
     @test A[Block(1, 1)] == A
+    @test A[BlockIndex((1,1), (1,2))] == A[1,2]
+    @test_throws BoundsError A[BlockIndex((1,1), (1,6))]
 
     @test similar(BlockVector{Float64}, Base.OneTo(5)) isa Vector{Float64}
     @test similar(BlockVector{Float64}, 5) isa Vector{Float64}

test/test_blockarrays.jl

@@ -345,6 +345,12 @@ end
     @testset "convert" begin
         # Could probably be DRY'd.
         A = PseudoBlockArray(rand(2,3), [1,1], [2,1])
+
+        @test convert(AbstractMatrix{Float64}, A) ≡ convert(AbstractMatrix, A) ≡ A
+        @test convert(AbstractArray{Float64}, A) ≡ convert(AbstractArray, A) ≡ A
+        @test convert(AbstractMatrix{Float32}, A) == AbstractMatrix{Float32}(A)
+        @test convert(AbstractArray{Float32}, A) == AbstractArray{Float32}(A)
+
         C = convert(BlockArray, A)
         @test C == A == BlockArray(A)
         @test eltype(C) == eltype(A)
@@ -365,6 +371,12 @@ end
 
 
         A = BlockArray(rand(2,3), [1,1], [2,1])
+
+        @test convert(AbstractMatrix{Float64}, A) ≡ convert(AbstractMatrix, A) ≡ A
+        @test convert(AbstractArray{Float64}, A) ≡ convert(AbstractArray, A) ≡ A
+        @test convert(AbstractMatrix{Float32}, A) == AbstractMatrix{Float32}(A)
+        @test convert(AbstractArray{Float32}, A) == AbstractArray{Float32}(A)
+
         C = convert(PseudoBlockArray, A)
         @test C == A == PseudoBlockArray(A)
         @test eltype(C) == eltype(A)