Add support for block fill arrays via BlockArrays.jl (#99)

* Add support for block fill arrays via BlockArrays.jl

* Support Block-Triangular-Fill printing

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "FillArrays"
 uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
-version = "0.8.9"
+version = "0.8.10"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/FillArrays.jl

@@ -7,7 +7,7 @@ import Base: size, getindex, setindex!, IndexStyle, checkbounds, convert,
     copy, vec, setindex!, count, ==, reshape, _throw_dmrs, map, zero
 
 import LinearAlgebra: rank, svdvals!, tril, triu, tril!, triu!, diag, transpose, adjoint, fill!,
-    norm2, norm1, normInf, normMinusInf, normp, lmul!, rmul!, diagzero
+    norm2, norm1, normInf, normMinusInf, normp, lmul!, rmul!, diagzero, AbstractTriangular
 
 import Base.Broadcast: broadcasted, DefaultArrayStyle, broadcast_shape
 
@@ -272,6 +272,11 @@ end
 @inline RectDiagonal{T}(A::V, args...) where {T,V} = RectDiagonal{T,V}(A, args...)
 @inline RectDiagonal(A::V, args...) where {V} = RectDiagonal{eltype(V),V}(A, args...)
 
+
+# patch missing overload from Base
+axes(rd::Diagonal{<:Any,<:AbstractFill}) = (axes(rd.diag,1),axes(rd.diag,1))
+axes(T::AbstractTriangular{<:Any,<:AbstractFill}) = axes(parent(T))
+
 axes(rd::RectDiagonal) = rd.axes
 size(rd::RectDiagonal) = length.(rd.axes)
 
@@ -302,15 +307,23 @@ for f in (:triu, :triu!, :tril, :tril!)
 end
 
 
+Base.replace_in_print_matrix(A::RectDiagonal, i::Integer, j::Integer, s::AbstractString) = 
+    i == j ? s : Base.replace_with_centered_mark(s)
+
+
 const RectOrDiagonal{T,V,Axes} = Union{RectDiagonal{T,V,Axes}, Diagonal{T,V}}
 const SquareEye{T,Axes} = Diagonal{T,Ones{T,1,Tuple{Axes}}}
 const Eye{T,Axes} = RectOrDiagonal{T,Ones{T,1,Tuple{Axes}}}
 
 @inline SquareEye{T}(n::Integer) where T = Diagonal(Ones{T}(n))
 @inline SquareEye(n::Integer) = Diagonal(Ones(n))
+@inline SquareEye{T}(ax::Tuple{AbstractUnitRange{Int}}) where T = Diagonal(Ones{T}(ax))
+@inline SquareEye(ax::Tuple{AbstractUnitRange{Int}}) = Diagonal(Ones(ax))
 
-@inline Eye{T}(n::Integer) where T = Diagonal(Ones{T}(n))
-@inline Eye(n::Integer) = Diagonal(Ones(n))
+@inline Eye{T}(n::Integer) where T = SquareEye{T}(n)
+@inline Eye(n::Integer) = SquareEye(n)
+@inline Eye{T}(ax::Tuple{AbstractUnitRange{Int}}) where T = SquareEye{T}(ax)
+@inline Eye(ax::Tuple{AbstractUnitRange{Int}}) = SquareEye(ax)
 
 # function iterate(iter::Eye, istate = (1, 1))
 #     (i::Int, j::Int) = istate
@@ -328,9 +341,21 @@ end
 
 Eye(n::Integer, m::Integer) = RectDiagonal(Ones(min(n,m)), n, m)
 Eye{T}(n::Integer, m::Integer) where T = RectDiagonal{T}(Ones{T}(min(n,m)), n, m)
+function Eye{T}((a,b)::NTuple{2,AbstractUnitRange{Int}}) where T 
+    ab = length(a) ≤ length(b) ? a : b
+    RectDiagonal{T}(Ones{T}((ab,)), (a,b))
+end
+function Eye((a,b)::NTuple{2,AbstractUnitRange{Int}})
+    ab = length(a) ≤ length(b) ? a : b
+    RectDiagonal(Ones((ab,)), (a,b))
+end
+
+
 @deprecate Eye{T}(sz::Tuple{Vararg{Integer,2}}) where T Eye{T}(sz...)
 @deprecate Eye(sz::Tuple{Vararg{Integer,2}}) Eye{Float64}(sz...)
 
+
+
 @inline Eye{T}(A::AbstractMatrix) where T = Eye{T}(size(A)...)
 @inline Eye(A::AbstractMatrix) = Eye{eltype(A)}(size(A)...)
 
@@ -506,5 +531,20 @@ include("fillbroadcast.jl")
 Base.replace_in_print_matrix(::Zeros, ::Integer, ::Integer, s::AbstractString) =
     Base.replace_with_centered_mark(s)
 
+# following support blocked fill array printing via
+# BlockArrays.jl
+axes_print_matrix_row(_, io, X, A, i, cols, sep) =
+    Base.invoke(Base.print_matrix_row, Tuple{IO,AbstractVecOrMat,Vector,Integer,AbstractVector,AbstractString},
+                io, X, A, i, cols, sep)
+
+Base.print_matrix_row(io::IO,
+        X::Union{AbstractFill{<:Any,1},
+                 AbstractFill{<:Any,2},
+                 Diagonal{<:Any,<:AbstractFill{<:Any,1}},
+                 RectDiagonal,
+                 AbstractTriangular{<:Any,<:AbstractFill{<:Any,2}}
+                 }, A::Vector,
+        i::Integer, cols::AbstractVector, sep::AbstractString) =
+        axes_print_matrix_row(axes(X), io, X, A, i, cols, sep)
 
 end # module

src/fillbroadcast.jl

@@ -6,7 +6,7 @@ map(f::Function, r::AbstractFill) = Fill(f(getindex_value(r)), axes(r))
 ### Unary broadcasting
 
 function broadcasted(::DefaultArrayStyle{N}, op, r::AbstractFill{T,N}) where {T,N}
-    return Fill(op(getindex_value(r)), size(r))
+    return Fill(op(getindex_value(r)), axes(r))
 end
 
 broadcasted(::DefaultArrayStyle{N}, ::typeof(conj), r::Zeros{T,N}) where {T,N} = r

test/runtests.jl

@@ -97,6 +97,9 @@ import FillArrays: AbstractFill, RectDiagonal, SquareEye
     @test eltype(Eye(5)) == Float64
     @test eltype(Eye(5,6)) == Float64
 
+    @test Eye((Base.OneTo(5),)) ≡ SquareEye((Base.OneTo(5),)) ≡ Eye(5)
+    @test Eye((Base.OneTo(5),Base.OneTo(6))) ≡ Eye(5,6)
+
     for T in (Int, Float64)
         E = Eye{T}(5)
         M = Matrix{T}(I, 5, 5)
@@ -113,6 +116,9 @@ import FillArrays: AbstractFill, RectDiagonal, SquareEye
 
         @test AbstractArray{Float32}(E) == Eye{Float32}(5)
         @test AbstractArray{Float32}(E) == Eye{Float32}(5, 5)
+
+        @test Eye{T}(randn(4,5)) ≡ Eye{T}(4,5) ≡ Eye{T}((Base.OneTo(4),Base.OneTo(5)))
+        @test Eye{T}((Base.OneTo(5),)) ≡ SquareEye{T}((Base.OneTo(5),)) ≡ Eye{T}(5)
     end
 
     @testset "Bool should change type" begin
@@ -169,6 +175,7 @@ end
     @test expected[2, :] == expected_matrix[2, :]
     @test expected[5, :] == expected_matrix[5, :]
 
+
     for Typ in (RectDiagonal, RectDiagonal{Int}, RectDiagonal{Int, UnitRange{Int}})
         @test Typ(data) == expected[1:3, 1:3]
         @test Typ(data, expected_axes) == expected
@@ -187,6 +194,9 @@ end
     @test diag(mut) == [5, 2, 3]
     mut[2, 1] = 0
     @test_throws ArgumentError mut[2, 1] = 9
+
+    D = RectDiagonal([1.,2.], (Base.OneTo(3),Base.OneTo(2)))
+    @test stringmime("text/plain", D) == "3×2 RectDiagonal{Float64,Array{Float64,1},Tuple{Base.OneTo{$Int},Base.OneTo{$Int}}}:\n 1.0   ⋅ \n  ⋅   2.0\n  ⋅    ⋅ "
 end
 
 # Check that all pair-wise combinations of + / - elements of As and Bs yield the correct
@@ -538,6 +548,9 @@ end
         @test Zeros(5) ./ Fill(5.0, 5) ≡ Zeros(5) ./ 5.0 ≡ Zeros(5)
         @test Ones(5) .\ Zeros(5) ≡ 1 .\ Zeros(5) ≡ Zeros(5)
         @test Fill(5.0, 5) .\ Zeros(5) ≡ 5.0 .\ Zeros(5) ≡ Zeros(5)
+
+        @test conj.(Zeros(5)) ≡ Zeros(5)
+        @test conj.(Zeros{ComplexF64}(5)) ≡ Zeros{ComplexF64}(5)
     end
 
     @testset "support Ref" begin
@@ -564,6 +577,15 @@ end
         @test Ones(10) - Zeros(10) ≡ Ones(10)
         @test Fill(1,10) - Zeros(10) ≡ Fill(1.0,10)
     end
+
+    @testset "Zero .*" begin
+        @test Zeros{Int}(10) .* Zeros{Int}(10) ≡ Zeros{Int}(10)
+        @test randn(10) .* Zeros(10) ≡ Zeros(10)
+        @test Zeros(10) .* randn(10) ≡ Zeros(10)
+        @test (1:10) .* Zeros(10) ≡ Zeros(10)
+        @test Zeros(10) .* (1:10) ≡ Zeros(10)
+        @test_throws DimensionMismatch (1:11) .* Zeros(10)
+    end
 end
 
 @testset "map" begin
@@ -649,15 +671,6 @@ end
     @test allunique(Ones(0))
 end
 
-@testset "Zero .*" begin
-    @test Zeros{Int}(10) .* Zeros{Int}(10) ≡ Zeros{Int}(10)
-    @test randn(10) .* Zeros(10) ≡ Zeros(10)
-    @test Zeros(10) .* randn(10) ≡ Zeros(10)
-    @test (1:10) .* Zeros(10) ≡ Zeros(10)
-    @test Zeros(10) .* (1:10) ≡ Zeros(10)
-    @test_throws DimensionMismatch (1:11) .* Zeros(10)
-end
-
 @testset "iterate" begin
     for d in (0, 1, 2, 100)
         for T in (Float64, Int)
@@ -967,17 +980,24 @@ end
     @test_throws ArgumentError rmul!(x,2.0)
 end
 
-@testset "Diagonal{<:Fill}" begin
-    D = Diagonal(Fill(Fill(0.5,2,2),10))
-    @test @inferred(D[1,1]) === Fill(0.5,2,2)
-    @test @inferred(D[1,2]) === Fill(0.0,2,2)
-    D = Diagonal(Fill(Zeros(2,2),10))
-    @test @inferred(D[1,1]) === Zeros(2,2)
-    @test @inferred(D[1,2]) === Zeros(2,2)
-
-    D = Diagonal([Zeros(1,1), Zeros(2,2)])
-    @test @inferred(D[1,1]) === Zeros(1,1)
-    @test @inferred(D[1,2]) === Zeros(1,2)
-
-    @test_throws ArgumentError Diagonal(Fill(Ones(2,2),10))[1,2]
+@testset "Modified" begin
+    @testset "Diagonal{<:Fill}" begin
+        D = Diagonal(Fill(Fill(0.5,2,2),10))
+        @test @inferred(D[1,1]) === Fill(0.5,2,2)
+        @test @inferred(D[1,2]) === Fill(0.0,2,2)
+        @test axes(D) == (Base.OneTo(10),Base.OneTo(10))
+        D = Diagonal(Fill(Zeros(2,2),10))
+        @test @inferred(D[1,1]) === Zeros(2,2)
+        @test @inferred(D[1,2]) === Zeros(2,2)
+        D = Diagonal([Zeros(1,1), Zeros(2,2)])
+        @test @inferred(D[1,1]) === Zeros(1,1)
+        @test @inferred(D[1,2]) === Zeros(1,2)
+
+        @test_throws ArgumentError Diagonal(Fill(Ones(2,2),10))[1,2]
+    end
+    @testset "Triangular" begin
+        U = UpperTriangular(Ones(3,3))
+        @test U == UpperTriangular(ones(3,3))
+        @test axes(U) == (Base.OneTo(3),Base.OneTo(3))
+    end
 end