Update ldiv.jl (#4)

* Update ldiv.jl

* Add ldiv/rdiv

* Increase coverage

* v0.1.4

Author: dlfivefifty

Project.toml

@@ -1,7 +1,7 @@
 name = "ArrayLayouts"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 authors = ["Sheehan Olver <solver@mac.com>"]
-version = "0.1.3"
+version = "0.1.4"
 
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"

src/ArrayLayouts.jl

@@ -46,7 +46,7 @@ else
     import Base: require_one_based_indexing    
 end     
 
-export materialize, materialize!, MulAdd, muladd!, Ldiv, Rdiv, Lmul, Rmul, lmul, rmul, mul, MemoryLayout, AbstractStridedLayout,
+export materialize, materialize!, MulAdd, muladd!, Ldiv, Rdiv, Lmul, Rmul, lmul, rmul, ldiv, rdiv, mul, MemoryLayout, AbstractStridedLayout,
         DenseColumnMajor, ColumnMajor, ZerosLayout, FillLayout, AbstractColumnMajor, RowMajor, AbstractRowMajor,
         DiagonalLayout, ScalarLayout, SymTridiagonalLayout, HermitianLayout, SymmetricLayout, TriangularLayout, 
         UnknownLayout, AbstractBandedLayout, ApplyBroadcastStyle, ConjLayout, AbstractFillLayout,

src/ldiv.jl

@@ -5,45 +5,44 @@ for Typ in (:Ldiv, :Rdiv)
             B::BType
         end
 
-        $Typ{StyleA, StyleB}(A::AType, B::BType) where {StyleA,StyleB,AType,BType} =
+        @inline $Typ{StyleA, StyleB}(A::AType, B::BType) where {StyleA,StyleB,AType,BType} =
             $Typ{StyleA,StyleB,AType,BType}(A,B)
 
-        $Typ(A::AType, B::BType) where {AType,BType} =
+        @inline $Typ(A::AType, B::BType) where {AType,BType} =
             $Typ{typeof(MemoryLayout(AType)),typeof(MemoryLayout(BType)),AType,BType}(A, B)
 
-        BroadcastStyle(::Type{<:$Typ}) = ApplyBroadcastStyle()
-        broadcastable(M::$Typ) = M
+        @inline BroadcastStyle(::Type{<:$Typ}) = ApplyBroadcastStyle()
+        @inline broadcastable(M::$Typ) = M
 
         similar(A::$Typ, ::Type{T}, axes) where T = similar(Array{T}, axes)
         similar(A::$Typ, ::Type{T}) where T = similar(A, T, axes(A))
         similar(A::$Typ) = similar(A, eltype(A))
 
-        copy(M::$Typ) = copyto!(similar(M), M)
-        materialize(M::$Typ) = copy(instantiate(M))
+        @inline copy(M::$Typ) = copyto!(similar(M), M)
+        @inline materialize(M::$Typ) = copy(instantiate(M))
     end
 end
 
-size(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractMatrix}) = (size(L.A, 2),size(L.B,2))
-size(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractVector}) = (size(L.A, 2),)
-axes(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractMatrix}) = (axes(L.A, 2),axes(L.B,2))
-axes(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractVector}) = (axes(L.A, 2),)
-length(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractVector}) =size(L.A, 2)
+@inline _ldivaxes(::Tuple{}, ::Tuple{}) = ()
+@inline _ldivaxes(::Tuple{}, Bax::Tuple) = Bax
+@inline _ldivaxes(::Tuple{<:Any}, ::Tuple{<:Any}) = ()
+@inline _ldivaxes(::Tuple{<:Any}, Bax::Tuple{<:Any,<:Any}) = (OneTo(1),last(Bax))
+@inline _ldivaxes(Aax::Tuple{<:Any,<:Any}, ::Tuple{<:Any}) = (last(Aax),)
+@inline _ldivaxes(Aax::Tuple{<:Any,<:Any}, Bax::Tuple{<:Any,<:Any}) = (last(Aax),last(Bax))
 
-size(L::Rdiv) = (size(L.A, 1),size(L.B,1))
-axes(L::Rdiv) = (axes(L.A, 1),axes(L.B,1))
+@inline ldivaxes(A, B) = _ldivaxes(axes(A), axes(B))
 
-_ldivaxes(::Tuple{}, ::Tuple{}) = ()
-_ldivaxes(::Tuple{}, Bax::Tuple) = Bax
-_ldivaxes(::Tuple{<:Any}, ::Tuple{<:Any}) = ()
-_ldivaxes(::Tuple{<:Any}, Bax::Tuple{<:Any,<:Any}) = (OneTo(1),last(Bax))
-_ldivaxes(Aax::Tuple{<:Any,<:Any}, ::Tuple{<:Any}) = (last(Aax),)
-_ldivaxes(Aax::Tuple{<:Any,<:Any}, Bax::Tuple{<:Any,<:Any}) = (last(Aax),last(Bax))
+@inline axes(L::Ldiv) = ldivaxes(L.A, L.B)
+@inline size(L::Ldiv) = map(length, axes(L))
+@inline length(L::Ldiv{<:Any,<:Any,<:Any,<:AbstractVector}) =size(L.A, 2)
 
-@inline ldivaxes(A, B) = _ldivaxes(axes(A), axes(B))
+@inline size(L::Rdiv) = (size(L.A, 1),size(L.B,1))
+@inline axes(L::Rdiv) = (axes(L.A, 1),axes(L.B,1))
 
-ndims(L::Ldiv) = ndims(last(L.args))
-eltype(M::Ldiv) = promote_type(Base.promote_op(inv, eltype(M.A)), eltype(M.B))
-eltype(M::Rdiv) = promote_type(eltype(M.A), Base.promote_op(inv, eltype(M.B)))
+@inline ndims(L::Ldiv) = ndims(L.B)
+@inline ndims(L::Rdiv) = 2
+@inline eltype(M::Ldiv) = promote_type(Base.promote_op(inv, eltype(M.A)), eltype(M.B))
+@inline eltype(M::Rdiv) = promote_type(eltype(M.A), Base.promote_op(inv, eltype(M.B)))
 
 
 check_ldiv_axes(A, B) =
@@ -54,34 +53,35 @@ check_rdiv_axes(A, B) =
 
 
 
-function instantiate(L::Ldiv)
+@inline function instantiate(L::Ldiv)
     check_ldiv_axes(L.A, L.B)
     Ldiv(instantiate(L.A), instantiate(L.B))
 end
 
-function instantiate(L::Rdiv)
+@inline function instantiate(L::Rdiv)
     check_rdiv_axes(L.A, L.B)
     Rdiv(instantiate(L.A), instantiate(L.B))
 end
 
-_ldiv!(A, B) = ldiv!(factorize(A), B)
-_ldiv!(A::Factorization, B) = ldiv!(A, B)
-
-_ldiv!(dest, A, B) = ldiv!(dest, factorize(A), B)
-_ldiv!(dest, A::Factorization, B) = ldiv!(dest, A, B)
-_ldiv!(dest, A::Transpose{<:Any,<:Factorization}, B) = ldiv!(dest, A, B)
-_ldiv!(dest, A::Adjoint{<:Any,<:Factorization}, B) = ldiv!(dest, A, B)
+@inline _ldiv!(A, B) = ldiv!(factorize(A), B)
+@inline _ldiv!(A::Factorization, B) = ldiv!(A, B)
 
+@inline _ldiv!(dest, A, B) = ldiv!(dest, factorize(A), B)
+@inline _ldiv!(dest, A::Factorization, B) = ldiv!(dest, A, B)
+@inline _ldiv!(dest, A::Transpose{<:Any,<:Factorization}, B) = ldiv!(dest, A, B)
+@inline _ldiv!(dest, A::Adjoint{<:Any,<:Factorization}, B) = ldiv!(dest, A, B)
 
+@inline ldiv(A, B) = materialize(Ldiv(A,B))
+@inline rdiv(A, B) = materialize(Rdiv(A,B))
 
-materialize!(M::Ldiv) = _ldiv!(M.A, M.B)
-materialize!(M::Rdiv) = materialize!(Lmul(M.B', M.A'))'
-copyto!(dest::AbstractArray, M::Rdiv) = copyto!(dest', Ldiv(M.B', M.A'))'
+@inline materialize!(M::Ldiv) = _ldiv!(M.A, M.B)
+@inline materialize!(M::Rdiv) = materialize!(Lmul(M.B', M.A'))'
+@inline copyto!(dest::AbstractArray, M::Rdiv) = copyto!(dest', Ldiv(M.B', M.A'))'
 
 if VERSION ≥ v"1.1-pre"
-    copyto!(dest::AbstractArray, M::Ldiv) = _ldiv!(dest, M.A, M.B)
+    @inline copyto!(dest::AbstractArray, M::Ldiv) = _ldiv!(dest, M.A, M.B)
 else
-    copyto!(dest::AbstractArray, M::Ldiv) = _ldiv!(dest, M.A, copy(M.B))
+    @inline copyto!(dest::AbstractArray, M::Ldiv) = _ldiv!(dest, M.A, copy(M.B))
 end
 
 const MatLdivVec{styleA, styleB, T, V} = Ldiv{styleA, styleB, <:AbstractMatrix{T}, <:AbstractVector{V}}

test/test_ldiv.jl

@@ -7,10 +7,11 @@ import ArrayLayouts: ApplyBroadcastStyle
         b = randn(5)
         M = Ldiv(A,b)
 
+        @test ndims(M) == 1
         @test size(M) == (5,)
         @test similar(M) isa Vector{Float64}
         @test materialize(M) isa Vector{Float64}
-        @test all(materialize(M) .=== (A\b))
+        @test all(materialize(M) .=== (A\b) .=== ldiv(A,b))
 
         @test Base.BroadcastStyle(typeof(Ldiv(A,b))) isa ApplyBroadcastStyle
 
@@ -99,6 +100,8 @@ import ArrayLayouts: ApplyBroadcastStyle
             B = randn(5,5)
             M = Rdiv(A,B)
 
+            @test eltype(M) == Float64
+            @test ndims(M) == 2
             @test size(M) == (3,5)
             @test axes(M) == (Base.OneTo(3),Base.OneTo(5))
             @test similar(M) isa Matrix{Float64}
@@ -109,17 +112,17 @@ import ArrayLayouts: ApplyBroadcastStyle
         D = Diagonal(randn(5))
         F = Eye(5)
         A = randn(5,5)
-        @test copy(Ldiv(D,F)) == D \ F
-        @test copy(Ldiv(F,D)) == F \ D
-        @test copy(Ldiv(D,A)) ≈ D \ A
-        @test copy(Ldiv(A,D)) == A \ D
-        @test copy(Ldiv(F,A)) ≈ F \ A
-        @test copy(Ldiv(A,F)) == A \ F
-
-        @test copy(Rdiv(D,F)) == D / F
-        @test copy(Rdiv(F,D)) == F / D
-        @test copy(Rdiv(A,D)) ≈ A / D
-        @test copy(Rdiv(A,F)) == A / F
+        @test copy(Ldiv(D,F)) == ldiv(D,F) == D \ F
+        @test ldiv(F,D) == F \ D
+        @test ldiv(D,A) ≈ D \ A
+        @test ldiv(A,D) == A \ D
+        @test ldiv(F,A) ≈ F \ A
+        @test ldiv(A,F) == A \ F
+
+        @test copy(Rdiv(D,F)) == rdiv(D,F) == D / F
+        @test rdiv(F,D) == F / D
+        @test rdiv(A,D) ≈ A / D
+        @test rdiv(A,F) == A / F
     end
 end