From 224f504c9a003a5f52f1a86df5c8b5f0b70657fa Mon Sep 17 00:00:00 2001 From: Sheehan Olver Date: Fri, 27 Mar 2020 09:55:57 +0000 Subject: [PATCH] ArrayLayouts 0.2 (#99) * ArrayLayouts 0.2 * v0.16 * Update runtests.jl * Update .travis.yml --- .travis.yml | 3 --- Project.toml | 4 ++-- src/LazyArrays.jl | 4 ++-- src/cache.jl | 2 +- src/lazyapplying.jl | 23 ++++++++++++++++------- src/lazyconcat.jl | 4 ++-- src/linalg/lazymul.jl | 1 - test/lazymultests.jl | 42 +----------------------------------------- test/runtests.jl | 14 ++++++++++++++ 9 files changed, 38 insertions(+), 59 deletions(-) diff --git a/.travis.yml b/.travis.yml index 176de900..6f4b4ab8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,9 +5,6 @@ os: - osx julia: - 1.0 - - 1.1 - - 1.2 - - 1.3 - 1.4 - nightly matrix: diff --git a/Project.toml b/Project.toml index c8dd4c18..bc71f448 100644 --- a/Project.toml +++ b/Project.toml @@ -1,6 +1,6 @@ name = "LazyArrays" uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02" -version = "0.15.1" +version = "0.16" [deps] ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" @@ -10,7 +10,7 @@ MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" [compat] -ArrayLayouts = "0.1" +ArrayLayouts = "0.2" FillArrays = "0.8" MacroTools = "0.5" StaticArrays = "0.11, 0.12" diff --git a/src/LazyArrays.jl b/src/LazyArrays.jl index eb3e6abc..9d60701a 100644 --- a/src/LazyArrays.jl +++ b/src/LazyArrays.jl @@ -37,7 +37,7 @@ import Base.Broadcast: BroadcastStyle, AbstractArrayStyle, Broadcasted, broadcas materialize!, eltypes import LinearAlgebra: AbstractTriangular, AbstractQ, checksquare, pinv, fill!, tilebufsize, Abuf, Bbuf, Cbuf, dot, factorize, qr, lu, cholesky, - norm2, norm1, normInf, normp, normMinusInf, det, tr, AdjOrTrans + norm2, norm1, normInf, normp, normMinusInf, det, tr, AdjOrTrans, triu, tril import LinearAlgebra.BLAS: BlasFloat, BlasReal, BlasComplex @@ -49,7 +49,7 @@ import ArrayLayouts: MatMulVecAdd, MatMulMatAdd, MulAdd, Lmul, Rmul, Ldiv, transposelayout, conjlayout, sublayout, triangularlayout, triangulardata, reshapedlayout, diagonallayout, adjointlayout, sub_materialize, check_mul_axes, _mul_eltype, check_ldiv_axes, ldivaxes, colsupport, rowsupport, - _fill_lmul!, @lazylmul, scalarone, scalarzero, fillzeros, zero!, lazy_getindex + _fill_lmul!, scalarone, scalarzero, fillzeros, zero!, layout_getindex if VERSION < v"1.2-" import Base: has_offset_axes diff --git a/src/cache.jl b/src/cache.jl index 9ff19dd7..b2514e03 100644 --- a/src/cache.jl +++ b/src/cache.jl @@ -73,7 +73,7 @@ function getindex(A::CachedArray, I...) A.data[I...] end -@inline getindex(A::CachedMatrix, kr::AbstractUnitRange, jr::AbstractUnitRange) = lazy_getindex(A, kr, jr) +@inline getindex(A::CachedMatrix, kr::AbstractUnitRange, jr::AbstractUnitRange) = layout_getindex(A, kr, jr) getindex(A::CachedVector, ::Colon) = copy(A) getindex(A::CachedVector, ::Slice) = copy(A) diff --git a/src/lazyapplying.jl b/src/lazyapplying.jl index 9624ad0d..cf45ed17 100644 --- a/src/lazyapplying.jl +++ b/src/lazyapplying.jl @@ -143,7 +143,7 @@ getindex(A::Applied, kj...) = materialize(A)[kj...] Wrap a lazy object that wraps a computation producing an array to an array. """ -abstract type LazyArray{T,N} <: AbstractArray{T,N} end +abstract type LazyArray{T,N} <: LayoutArray{T,N} end const LazyMatrix{T} = LazyArray{T,2} const LazyVector{T} = LazyArray{T,1} @@ -267,12 +267,6 @@ end # on the memory layout ### -@inline getindex(A::LazyMatrix, kr::Colon, jr::Colon) = lazy_getindex(A, kr, jr) -@inline getindex(A::LazyMatrix, kr::Colon, jr::AbstractUnitRange) = lazy_getindex(A, kr, jr) -@inline getindex(A::LazyVector, kr::AbstractUnitRange) = lazy_getindex(A, kr) -@inline getindex(A::LazyMatrix, kr::AbstractUnitRange, jr::Colon) = lazy_getindex(A, kr, jr) -@inline getindex(A::LazyMatrix, kr::AbstractUnitRange, jr::AbstractUnitRange) = lazy_getindex(A, kr, jr) - @inline copyto!(dest::AbstractArray{T,N}, src::ApplyArray{T,N}) where {T,N} = copyto!(dest, Applied(src)) @inline copyto!(dest::AbstractArray, src::ApplyArray) = copyto!(dest, Applied(src)) @@ -294,6 +288,8 @@ for tri in (:tril, :triu) @eval begin ndims(::Applied{<:Any,typeof($tri)}) = 2 eltype(A::Applied{<:Any,typeof($tri)}) = eltype(first(A.args)) + $tri(A::LazyMatrix) = ApplyMatrix($tri, A) + $tri(A::LazyMatrix, k::Integer) = ApplyMatrix($tri, A, k) end end @@ -303,7 +299,20 @@ getindex(A::ApplyMatrix{T,typeof(triu),<:Tuple{<:AbstractMatrix}}, k::Integer, j getindex(A::ApplyMatrix{T,typeof(triu),<:Tuple{<:AbstractMatrix,<:Integer}}, k::Integer, j::Integer) where T = j ≥ k+A.args[2] ? A.args[1][k,j] : zero(T) +getindex(A::ApplyMatrix{T,typeof(tril),<:Tuple{<:AbstractMatrix}}, k::Integer, j::Integer) where T = + j ≤ k ? A.args[1][k,j] : zero(T) + +getindex(A::ApplyMatrix{T,typeof(tril),<:Tuple{<:AbstractMatrix,<:Integer}}, k::Integer, j::Integer) where T = + j ≤ k+A.args[2] ? A.args[1][k,j] : zero(T) + + replace_in_print_matrix(A::ApplyMatrix{<:Any,typeof(triu),<:Tuple{<:AbstractMatrix}}, i::Integer, j::Integer, s::AbstractString) = j ≥ i ? replace_in_print_matrix(A.args[1], i, j, s) : replace_with_centered_mark(s) replace_in_print_matrix(A::ApplyMatrix{<:Any,typeof(triu),<:Tuple{<:AbstractMatrix,<:Integer}}, i::Integer, j::Integer, s::AbstractString) = j ≥ i+A.args[2] ? replace_in_print_matrix(A.args[1], i, j, s) : replace_with_centered_mark(s) + + +replace_in_print_matrix(A::ApplyMatrix{<:Any,typeof(tril),<:Tuple{<:AbstractMatrix}}, i::Integer, j::Integer, s::AbstractString) = + j ≤ i ? replace_in_print_matrix(A.args[1], i, j, s) : replace_with_centered_mark(s) +replace_in_print_matrix(A::ApplyMatrix{<:Any,typeof(tril),<:Tuple{<:AbstractMatrix,<:Integer}}, i::Integer, j::Integer, s::AbstractString) = + j ≤ i+A.args[2] ? replace_in_print_matrix(A.args[1], i, j, s) : replace_with_centered_mark(s) diff --git a/src/lazyconcat.jl b/src/lazyconcat.jl index c0927af9..6e81eb21 100644 --- a/src/lazyconcat.jl +++ b/src/lazyconcat.jl @@ -662,7 +662,7 @@ sublayout(::PaddedLayout{L}, ::Type{I}) where {L,I<:Tuple{AbstractUnitRange}} = sublayout(::PaddedLayout{L}, ::Type{I}) where {L,I<:Tuple{AbstractUnitRange,AbstractUnitRange}} = PaddedLayout{typeof(sublayout(L(), I))}() -_lazy_getindex(dat, kr2) = lazy_getindex(dat, kr2) +_lazy_getindex(dat, kr2) = layout_getindex(dat, kr2) _lazy_getindex(dat::Number, kr2) = dat function sub_materialize(::PaddedLayout, v::AbstractVector{T}) where T @@ -678,7 +678,7 @@ function sub_materialize(::PaddedLayout, v::AbstractMatrix{T}) where T dat = paddeddata(A) kr,jr = parentindices(v) kr2 = kr ∩ axes(dat,1) - Vcat(lazy_getindex(dat, kr2, jr), Zeros{T}(length(kr) - length(kr2), length(jr))) + Vcat(layout_getindex(dat, kr2, jr), Zeros{T}(length(kr) - length(kr2), length(jr))) end ## print diff --git a/src/linalg/lazymul.jl b/src/linalg/lazymul.jl index f6645491..3b98b611 100644 --- a/src/linalg/lazymul.jl +++ b/src/linalg/lazymul.jl @@ -86,7 +86,6 @@ macro lazyldiv(Typ) end @lazymul LazyMatrix -@lazylmul LazyMatrix @lazyldiv LazyMatrix diff --git a/test/lazymultests.jl b/test/lazymultests.jl index b3851f92..7717ace7 100644 --- a/test/lazymultests.jl +++ b/test/lazymultests.jl @@ -1,5 +1,5 @@ using LazyArrays, LinearAlgebra -import LazyArrays: @lazymul, @lazylmul, @lazyldiv, materialize!, MemoryLayout, triangulardata, LazyLayout, LazyArrayApplyStyle, UnknownLayout +import LazyArrays: @lazymul, @lazyldiv, materialize!, MemoryLayout, triangulardata, LazyLayout, LazyArrayApplyStyle, UnknownLayout # used to test general matrix backends struct MyMatrix{T} <: AbstractMatrix{T} @@ -29,35 +29,6 @@ LinearAlgebra.factorize(A::MyMatrix) = factorize(A.A) @lazymul MyMatrix @lazyldiv MyMatrix -struct MyUpperTriangular{T} <: AbstractMatrix{T} - A::UpperTriangular{T,Matrix{T}} -end - -MyUpperTriangular{T}(::UndefInitializer, n::Int, m::Int) where T = MyUpperTriangular{T}(UpperTriangular(Array{T}(undef, n, m))) -MyUpperTriangular(A::AbstractMatrix{T}) where T = MyUpperTriangular{T}(UpperTriangular(Matrix{T}(A))) -Base.convert(::Type{MyUpperTriangular{T}}, A::MyUpperTriangular{T}) where T = A -Base.convert(::Type{MyUpperTriangular{T}}, A::MyUpperTriangular) where T = MyUpperTriangular(convert(AbstractArray{T}, A.A)) -Base.convert(::Type{MyUpperTriangular}, A::MyUpperTriangular)= A -Base.convert(::Type{AbstractArray{T}}, A::MyUpperTriangular) where T = MyUpperTriangular(convert(AbstractArray{T}, A.A)) -Base.convert(::Type{AbstractMatrix{T}}, A::MyUpperTriangular) where T = MyUpperTriangular(convert(AbstractArray{T}, A.A)) -Base.convert(::Type{MyUpperTriangular{T}}, A::AbstractArray{T}) where T = MyUpperTriangular{T}(A) -Base.convert(::Type{MyUpperTriangular{T}}, A::AbstractArray) where T = MyUpperTriangular{T}(convert(AbstractArray{T}, A)) -Base.convert(::Type{MyUpperTriangular}, A::AbstractArray{T}) where T = MyUpperTriangular{T}(A) -Base.getindex(A::MyUpperTriangular, kj...) = A.A[kj...] -Base.getindex(A::MyUpperTriangular, ::Colon, j::AbstractVector) = MyUpperTriangular(A.A[:,j]) -Base.setindex!(A::MyUpperTriangular, v, kj...) = setindex!(A.A, v, kj...) -Base.size(A::MyUpperTriangular) = size(A.A) -Base.similar(::Type{MyUpperTriangular{T}}, m::Int, n::Int) where T = MyUpperTriangular{T}(undef, m, n) -Base.similar(::MyUpperTriangular{T}, m::Int, n::Int) where T = MyUpperTriangular{T}(undef, m, n) -Base.similar(::MyUpperTriangular, ::Type{T}, m::Int, n::Int) where T = MyUpperTriangular{T}(undef, m, n) -LinearAlgebra.factorize(A::MyUpperTriangular) = factorize(A.A) - -MemoryLayout(::Type{MyUpperTriangular{T}}) where T = MemoryLayout(UpperTriangular{T,Matrix{T}}) -triangulardata(A::MyUpperTriangular) = triangulardata(A.A) - -@lazylmul MyUpperTriangular - - struct MyLazyArray{T,N} <: AbstractArray{T,N} data::Array{T,N} end @@ -120,17 +91,6 @@ LinearAlgebra.factorize(A::MyLazyArray) = factorize(A.data) @test BroadcastArray(exp,A) * BroadcastArray(exp,B) ≈ apply(*, BroadcastArray(exp,A),BroadcastArray(exp,B)) ≈ exp.(A)*exp.(B) end - @testset "lmul!" begin - A = randn(5,5) - B = randn(5,5) - x = randn(5) - - @test lmul!(MyUpperTriangular(A), copy(x)) ≈ MyUpperTriangular(A) * x - @test lmul!(MyUpperTriangular(A), copy(B)) ≈ MyUpperTriangular(A) * B - - @test_skip lmul!(MyUpperTriangular(A),view(copy(B),collect(1:5),1:5)) ≈ MyUpperTriangular(A) * B - end - @testset "\\" begin A = randn(5,5) B = randn(5,5) diff --git a/test/runtests.jl b/test/runtests.jl index 9585a6ec..9f8972cf 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -189,16 +189,30 @@ end @testset "triu/tril" begin A = ApplyArray(triu,randn(2,2)) @test A isa ApplyArray{Float64} + @test A[2,1] == 0 + @test A[1,1] == A.args[1][1,1] @test A == triu(A.args[1]) A = ApplyArray(tril,randn(2,2)) @test A isa ApplyArray{Float64} + @test A[1,2] == 0 + @test A[1,1] == A.args[1][1,1] @test A == tril(A.args[1]) A = ApplyArray(triu,randn(2,2),1) + @test A[1,1] == 0 + @test A[1,2] == A.args[1][1,2] @test A isa ApplyArray{Float64} @test A == triu(A.args[1],1) A = ApplyArray(tril,randn(2,2),-1) @test A isa ApplyArray{Float64} + @test A[1,1] == 0 + @test A[2,1] == A.args[1][2,1] @test A == tril(A.args[1],-1) + + A = ApplyMatrix(exp,randn(2,2)) + @test triu(A) isa ApplyMatrix{Float64,typeof(triu)} + @test tril(A) isa ApplyMatrix{Float64,typeof(tril)} + @test triu(A,1) isa ApplyMatrix{Float64,typeof(triu)} + @test tril(A,1) isa ApplyMatrix{Float64,typeof(tril)} end @testset "BroadcastArray" begin