Support new ArrayLayouts (#127)

* Update Project.toml

* Update blockaxis.jl

* Update Project.toml

* fix elsize

* broadcasting for FillArrays

* Update Project.toml

* Update test_blockarrayinterface.jl

* Add tests

* Tests pass

* Update Project.toml

Author: dlfivefifty

Project.toml

@@ -1,15 +1,17 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.12.11"
+version = "0.12.12"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
+FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
-ArrayLayouts = "0.3.8"
+ArrayLayouts = "0.4.1"
 Compat = "2.2, 3"
+FillArrays = "0.9.2"
 julia = "1.1"
 
 [extras]

src/BlockArrays.jl

@@ -1,6 +1,6 @@
 module BlockArrays
 using Base.Cartesian
-using LinearAlgebra, ArrayLayouts
+using LinearAlgebra, ArrayLayouts, FillArrays
 
 # AbstractBlockArray interface exports
 export AbstractBlockArray, AbstractBlockMatrix, AbstractBlockVector, AbstractBlockVecOrMat

src/blockarray.jl

@@ -313,7 +313,7 @@ convert(::Type{BlockArray{T1}}, A::AbstractArray{T2, N}) where {T1,T2,N} =
 convert(::Type{BlockArray}, A::AbstractArray{T, N}) where {T,N} =
     convert(BlockArray{T, N}, A)
 
-copy(A::BlockArray) = _BlockArray(copy.(A.blocks), A.axes)
+copy(A::BlockArray) = _BlockArray(map(copy,A.blocks), A.axes)
 
 ################################
 # AbstractBlockArray Interface #

src/blockaxis.jl

@@ -100,7 +100,7 @@ julia> blockaxes(A)[1]
 ```
 """
 blockaxes(b::BlockedUnitRange) = (Block.(axes(b.lasts,1)),)
-blockaxes(b::AbstractArray{<:Any,N}) where N = blockaxes.(axes(b), 1)
+blockaxes(b) = blockaxes.(axes(b), 1)
 
 """
     blockaxes(A, d)

src/blockbroadcast.jl

@@ -231,4 +231,23 @@ _blocktype(::Type{<:BlockArray{<:Any,N,<:AbstractArray{R,N}}}) where {N,R} = R
 BroadcastStyle(::Type{<:SubArray{T,N,Arr,<:NTuple{N,BlockSlice1},false}}) where {T,N,Arr<:BlockArray} = 
     BroadcastStyle(_blocktype(Arr))
 BroadcastStyle(::Type{<:SubArray{T,N,Arr,<:NTuple{N,BlockSlice{BlockRange{1,Tuple{II}}}},false}}) where {T,N,Arr<:BlockArray,II} = 
-    BroadcastStyle(Arr)
+    BroadcastStyle(Arr)
+
+
+###
+# Fill
+###
+
+for op in (:*, :/)
+    @eval begin
+        broadcasted(::AbstractBlockStyle, ::typeof($op), a::Zeros, b::AbstractArray) = FillArrays._broadcasted_zeros(a, b)
+        broadcasted(::AbstractBlockStyle, ::typeof($op), a::Ones{T}, b::AbstractArray{V}) where {T,V} = LinearAlgebra.copy_oftype(b, Base.promote_op(*, T, V))
+    end
+end
+
+for op in (:*, :\)
+    @eval begin
+        broadcasted(::AbstractBlockStyle, ::typeof($op), a::AbstractArray, b::Zeros) = FillArrays._broadcasted_zeros(a, b)
+        broadcasted(::AbstractBlockStyle, ::typeof($op), a::AbstractArray{T}, b::Ones{V}) where {T,V} = LinearAlgebra.copy_oftype(a, Base.promote_op(*, T, V))
+    end
+end

src/pseudo_blockarray.jl

@@ -323,7 +323,7 @@ Base.stride(A::PseudoBlockArray, i::Integer) = stride(A.blocks, i)
 Base.unsafe_convert(::Type{Ptr{T}}, A::PseudoBlockArray) where T = Base.unsafe_convert(Ptr{T}, A.blocks)
 
 if VERSION ≥ v"1.5"
-    Base.elsize(::Type{<:PseudoBlockArray{T}}) where {T} = Base.aligned_sizeof(T)
+    Base.elsize(::Type{<:PseudoBlockArray{T,N,R}}) where {T,N,R} = Base.elsize(R)
 end
 
 ###

test/test_blockarrayinterface.jl

@@ -137,7 +137,7 @@ end
     U = UpperTriangular(Ones((blockedrange([1,2]),blockedrange([2,1]))))
 
     if VERSION ≥ v"1.2"
-        @test stringmime("text/plain", A) == "5-element Fill{Int64,1,Tuple{BlockedUnitRange{Array{Int64,1}}}} with indices 1:1:5:\n 2\n ─\n 2\n 2\n ─\n 2\n 2"
+        @test stringmime("text/plain", A) == "5-element Fill{Int64,1,Tuple{BlockedUnitRange{Array{Int64,1}}}} with indices 1:1:5: entries equal to 2"
         @test stringmime("text/plain", B) == "3×3 Diagonal{Float64,Ones{Float64,1,Tuple{BlockedUnitRange{Array{Int64,1}}}}} with indices 1:1:3×1:1:3:\n 1.0  │   ⋅    ⋅ \n ─────┼──────────\n  ⋅   │  1.0   ⋅ \n  ⋅   │   ⋅   1.0"
         @test stringmime("text/plain", U) == "3×3 UpperTriangular{Float64,Ones{Float64,2,Tuple{BlockedUnitRange{Array{Int64,1}},BlockedUnitRange{Array{Int64,1}}}}} with indices 1:1:3×1:1:3:\n 1.0  1.0  │  1.0\n ──────────┼─────\n  ⋅   1.0  │  1.0\n  ⋅    ⋅   │  1.0"
     end

test/test_blockbroadcast.jl

@@ -131,4 +131,10 @@ using BlockArrays, FillArrays, Test
         @test -V isa BlockArray
         @test -V == -A[Block.(2:3)]
     end
+
+    @testset "Fill broadcast" begin
+        A = BlockArray(randn(6), 1:3)
+        @test blockisequal(axes(A .* Zeros(6)), axes(A .* zeros(6)))
+        @test blockisequal(axes(A .* Ones(6)), axes(A .* ones(6)))
+    end
 end