Add * overloads coming from v0.9 (#141)

* Add * overloads coming from v0.9

* Rmul with DualLayout and Diagonal

* Add zeros mul tests

* v1.0.7

* Update diagonal.jl

* increase coverage

Author: dlfivefifty

Project.toml

@@ -1,15 +1,15 @@
 name = "ArrayLayouts"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 authors = ["Sheehan Olver <solver@mac.com>"]
-version = "1.0.6"
+version = "1.0.7"
 
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
-FillArrays = "1.0"
+FillArrays = "1.2.1"
 julia = "1.6"
 
 [extras]

src/ArrayLayouts.jl

@@ -184,8 +184,11 @@ getindex(A::AdjOrTrans{<:Any,<:LayoutVector}, kr::Integer, jr::AbstractVector) =
 
 *(a::Zeros{<:Any,2}, b::LayoutMatrix) = FillArrays.mult_zeros(a, b)
 *(a::LayoutMatrix, b::Zeros{<:Any,2}) = FillArrays.mult_zeros(a, b)
+*(a::LayoutMatrix, b::Zeros{<:Any,1}) = FillArrays.mult_zeros(a, b)
 *(a::Transpose{T, <:LayoutMatrix{T}} where T, b::Zeros{<:Any, 2}) = FillArrays.mult_zeros(a, b)
 *(a::Adjoint{T, <:LayoutMatrix{T}} where T, b::Zeros{<:Any, 2}) = FillArrays.mult_zeros(a, b)
+*(A::Adjoint{<:Any, <:Zeros{<:Any,1}}, B::Diagonal{<:Any,<:LayoutVector}) = (B' * A')'
+*(A::Transpose{<:Any, <:Zeros{<:Any,1}}, B::Diagonal{<:Any,<:LayoutVector}) = transpose(transpose(B) * transpose(A))
 
 *(A::Diagonal{<:Any,<:LayoutVector}, B::Diagonal{<:Any,<:LayoutVector}) = mul(A, B)
 *(A::Diagonal{<:Any,<:LayoutVector}, B::AbstractMatrix) = mul(A, B)

src/diagonal.jl

@@ -20,6 +20,15 @@ copy(M::Lmul{<:DiagonalLayout}) = diagonaldata(M.A) .* M.B
 copy(M::Rmul{<:Any,<:DiagonalLayout}) = M.A .* permutedims(diagonaldata(M.B))
 
 
+dualadjoint(_) = adjoint
+dualadjoint(::Transpose) = transpose
+dualadjoint(V::SubArray) = dualadjoint(parent(V))
+function copy(M::Rmul{<:DualLayout,<:DiagonalLayout})
+    adj = dualadjoint(M.A)
+    adj(adj(M.B) * adj(M.A))
+end
+
+
 
 # Diagonal multiplication never changes structure
 similar(M::Rmul{<:Any,<:DiagonalLayout}, ::Type{T}, axes) where T = similar(M.A, T, axes)
@@ -60,10 +69,12 @@ copy(M::Lmul{DiagonalLayout{OnesLayout},<:DiagonalLayout}) = Diagonal(_copy_ofty
 copy(M::Lmul{<:DiagonalLayout,DiagonalLayout{OnesLayout}}) = Diagonal(_copy_oftype(diagonaldata(M.A), eltype(M)))
 copy(M::Lmul{DiagonalLayout{OnesLayout},DiagonalLayout{OnesLayout}}) = _copy_oftype(M.B, eltype(M))
 copy(M::Rmul{<:Any,DiagonalLayout{OnesLayout}}) = _copy_oftype(M.A, eltype(M))
+copy(M::Rmul{<:DualLayout,DiagonalLayout{OnesLayout}}) = _copy_oftype(M.A, eltype(M))
 
 copy(M::Lmul{<:DiagonalLayout{<:AbstractFillLayout}}) = getindex_value(diagonaldata(M.A)) * M.B
 copy(M::Lmul{<:DiagonalLayout{<:AbstractFillLayout},<:DiagonalLayout}) = getindex_value(diagonaldata(M.A)) * M.B
 copy(M::Rmul{<:Any,<:DiagonalLayout{<:AbstractFillLayout}}) = M.A * getindex_value(diagonaldata(M.B))
+copy(M::Rmul{<:DualLayout,<:DiagonalLayout{<:AbstractFillLayout}}) = M.A * getindex_value(diagonaldata(M.B))
 
 copy(M::Rmul{<:BidiagonalLayout,<:DiagonalLayout{<:AbstractFillLayout}}) = M.A * getindex_value(diagonaldata(M.B))
 copy(M::Lmul{<:DiagonalLayout{<:AbstractFillLayout},<:BidiagonalLayout}) = getindex_value(diagonaldata(M.A)) * M.B

src/mul.jl

@@ -300,6 +300,16 @@ end
 *(A::Transpose{<:Any,<:LayoutVector}, B::Adjoint{<:Any,<:LayoutMatrix}) = mul(A,B)
 *(A::Transpose{<:Any,<:LayoutVector}, B::Transpose{<:Any,<:LayoutMatrix}) = mul(A,B)
 
+## special routines introduced in v0.9. We need to avoid these to support ∞-arrays
+
+*(x::Adjoint{<:Any,<:LayoutVector},   D::Diagonal{<:Any,<:LayoutVector}) = mul(x, D)
+*(x::Transpose{<:Any,<:LayoutVector},   D::Diagonal{<:Any,<:LayoutVector}) = mul(x, D)
+*(x::AdjointAbsVec,   D::Diagonal, y::LayoutVector) = x * mul(D,y)
+*(x::TransposeAbsVec, D::Diagonal, y::LayoutVector) = x * mul(D,y)
+*(x::AdjointAbsVec{<:Any,<:Zeros{<:Any,1}},   D::Diagonal, y::LayoutVector) = FillArrays._triple_zeromul(x, D, y)
+*(x::TransposeAbsVec{<:Any,<:Zeros{<:Any,1}}, D::Diagonal, y::LayoutVector) = FillArrays._triple_zeromul(x, D, y)
+
+
 
 ###
 # Dot

test/test_layoutarray.jl

@@ -395,6 +395,53 @@ MemoryLayout(::Type{MyVector}) = DenseColumnMajor()
         @test x'A ≈ transpose(x)A ≈ x.A'A.A
         @test x'A' ≈ x'transpose(A) ≈ transpose(x)A' ≈ transpose(x)transpose(A) ≈ x.A'A.A'
     end
+
+    @testset "Zeros mul" begin
+        A = MyMatrix(randn(5,5))
+        @test A*Zeros(5) ≡ Zeros(5)
+        @test A*Zeros(5,2) ≡ Zeros(5,2)
+        @test Zeros(1,5) * A ≡ Zeros(1,5)
+        @test Zeros(5)' * A ≡ Zeros(5)'
+        @test transpose(Zeros(5)) * A ≡ transpose(Zeros(5))
+
+        @test Zeros(5)' * A * (1:5) == 
+            transpose(Zeros(5)) * A * (1:5) ==
+            (1:5)' * A * Zeros(5) ==
+            transpose(1:5) * A * Zeros(5) ==
+            Zeros(5)' * A * Zeros(5) ==
+            transpose(Zeros(5)) * A * Zeros(5) == 0.0
+    end
+
+    @testset "triple *" begin
+        D = Diagonal(1:5)
+        y = MyVector(randn(5))
+        @test (1:5)' *  D * y ≈ transpose(1:5) *  D * y ≈ (1:5)' * D * y.A
+        @test y' * D * y ≈ transpose(y) * D * y ≈ y.A' * D * y.A
+        @test y' * D * (1:5) ≈ y.A' * D * (1:5)
+        @test y' * Diagonal(y) isa Adjoint
+        @test transpose(y) * Diagonal(y) isa Transpose
+
+        @test y' * D isa Adjoint
+        @test transpose(y) * D isa Transpose
+
+        @test Zeros(5)' * D * y == transpose(Zeros(5)) * D * y == 0.0
+        @test y' * D * Zeros(5) == transpose(y) * D * Zeros(5) == 0.0
+        @test Zeros(5)' * Diagonal(y) ≡ Zeros(5)'
+        @test transpose(Zeros(5)) * Diagonal(y) ≡ transpose(Zeros(5))
+        @test Zeros(5)' * Diagonal(y) * y == 0.0
+        @test transpose(Zeros(5)) * Diagonal(y) * y == 0.0
+        @test y' * Diagonal(y) * Zeros(5) == 0.0
+        @test transpose(y) * Diagonal(y) * Zeros(5) == 0.0
+        @test Zeros(5)' * Diagonal(y) * Zeros(5) == 0.0
+        @test transpose(Zeros(5)) * Diagonal(y) * Zeros(5) == 0.0
+    end
+
+    @testset "rmul with lazy and Diagonal" begin
+        D = Diagonal(1:5)
+        y = MyVector(randn(5))
+        @test mul(view(y', :, 1:5), D) isa Adjoint
+        @test mul(view(transpose(y), :, 1:5), D) isa Transpose
+    end
 end
 
 struct MyUpperTriangular{T} <: AbstractMatrix{T}

test/test_layouts.jl

@@ -98,6 +98,9 @@ struct FooNumber <: Number end
             @test layout_getindex(transpose(a .+ im),:,1:3) == transpose((a .+ im)[1:3])
 
             @test ArrayLayouts._copyto!(similar(a'), a') == a'
+
+            @test mul(randn(5)', Diagonal(1:5)) isa Adjoint
+            @test mul(transpose(randn(5)), Diagonal(1:5)) isa Transpose
         end
     end