Latest FillArrays/LazyArrays (#15)

* FillArrays 0.7, BandedMatrix tests

* remove _materialize

* update for no VCat

* Banded Lazy

* similar(::Type, ...)

* v0.2

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "InfiniteArrays"
 uuid = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
-version = "0.1.3"
+version = "0.2"
 
 [deps]
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
@@ -9,10 +9,16 @@ LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 DSP = "0.5.1, 0.6"
-FillArrays = "0.6"
-LazyArrays = "0.10"
+FillArrays = "0.6, 0.7"
+LazyArrays = "0.11"
 julia = "1"
+
+[extras]
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
+
+[targets]
+test = ["Test", "BandedMatrices"]

src/InfiniteArrays.jl

@@ -34,9 +34,8 @@ import LinearAlgebra: BlasInt, BlasFloat, norm, diag, diagm, ishermitian, issymm
 import Statistics: mean, median
 
 import FillArrays: AbstractFill, getindex_value
-import LazyArrays: LazyArrayStyle, _materialize, AbstractBandedLayout,
-                    ZerosLayout, VcatLayout, @lazymul, mulapplystyle, AbstractArrayApplyStyle,
-                    ArrayMuls
+import LazyArrays: LazyArrayStyle, AbstractBandedLayout, MemoryLayout, LazyLayout,
+                    ZerosLayout, @lazymul, AbstractArrayApplyStyle
 
 import DSP: conv
 
@@ -93,16 +92,5 @@ UnitRange{T}(start::Integer, ::Infinity) where T<:Real = InfUnitRange{T}(start)
 
 Int(::Infinity) = ∞
 
-# stay lazy if infinite
-_materialize(M::Mul{<:AbstractArrayApplyStyle,<:Tuple{Vararg{<:AbstractArray}}}, ::Tuple{<:OneToInf,<:OneToInf}) = ApplyArray(M)
-_materialize(M::Mul{<:AbstractArrayApplyStyle,<:Tuple{Vararg{<:AbstractArray}}}, ::Tuple{<:OneToInf}) = ApplyArray(M)
-_materialize(M::Mul{<:AbstractArrayApplyStyle,<:Tuple{Vararg{<:AbstractArray}}}, ::Tuple{<:OneToInf,<:OneTo}) = ApplyArray(M)
-_materialize(M::Mul{<:AbstractArrayApplyStyle,<:Tuple{Vararg{<:AbstractArray}}}, ::Tuple{<:OneTo,<:OneToInf}) = ApplyArray(M)
-_materialize(M::ArrayMuls, ::Tuple{<:OneToInf,<:OneToInf}) = ApplyArray(M)
-_materialize(M::ArrayMuls, ::Tuple{<:OneToInf}) = ApplyArray(M)
-_materialize(M::ArrayMuls, ::Tuple{<:OneToInf,<:OneTo}) = ApplyArray(M)
-_materialize(M::ArrayMuls, ::Tuple{<:OneTo,<:OneToInf}) = ApplyArray(M)
-
-
 
 end # module

src/infarrays.jl

@@ -24,6 +24,12 @@ similar(A::AbstractArray, ::Type{T}, axes::Tuple{OneToInf{Int},OneToInf{Int}}) w
 similar(A::AbstractArray, ::Type{T}, dims::Tuple{Infinity}) where T = cache(Zeros{T}(dims))
 similar(A::AbstractArray, ::Type{T}, dims::Tuple{Infinity,Infinity}) where T = cache(Zeros{T}(dims))
 
+similar(::Type{<:AbstractArray{T}}, axes::Tuple{OneToInf{Int}}) where T = cache(Zeros{T}(axes))
+similar(::Type{<:AbstractArray{T}}, axes::Tuple{OneToInf{Int},OneToInf{Int}}) where T = cache(Zeros{T}(axes))
+similar(::Type{<:AbstractArray{T}}, dims::Tuple{Infinity}) where T = cache(Zeros{T}(dims))
+similar(::Type{<:AbstractArray{T}}, dims::Tuple{Infinity,Infinity}) where T = cache(Zeros{T}(dims))
+
+
 zeros(::Type{T}, ::Tuple{Infinity}) where T = cache(Zeros{T}(∞))
 zeros(::Type{T}, nm::Tuple{Integer, Infinity}) where T = cache(Zeros{T}(nm...))
 zeros(::Type{T}, nm::Tuple{Infinity, Integer}) where T = cache(Zeros{T}(nm...))
@@ -124,4 +130,4 @@ _gettail(k, a::Number, b...) = k ≤ 1 ? tuple(a, b...) : _gettail(k - length(a
 _gettail(k, a, b...) = k ≤ length(a) ? tuple(a[k:end], b...) : _gettail(k - length(a), b...)
 _vcat(a) = a
 _vcat(a, b, c...) = Vcat(a, b, c...)
-_unsafe_getindex(::IndexLinear, A::Vcat, r::InfUnitRange) = _vcat(_gettail(first(r), A.arrays...)...)
+_unsafe_getindex(::IndexLinear, A::Vcat, r::InfUnitRange) = _vcat(_gettail(first(r), A.args...)...)

src/infrange.jl

@@ -1,6 +1,7 @@
 # This file is mmodified from Julia. License is MIT: https://julialang.org/license
 
 (:)(start::T, stop::Infinity) where {T<:Integer} = InfUnitRange{T}(start)
+(:)(start::Infinity, stop::Integer) = start+1:start
 function (:)(start::T, step::T, stop::OrientedInfinity) where {T<:Real}
     sign(step) == sign(stop) || throw(ArgumentError("InfStepRange must have infinite length"))
     InfStepRange(start, step)
@@ -439,3 +440,11 @@ function conv(r1::Ones{<:Any,1,<:Tuple{<:OneToInf}}, r2::AbstractFill{<:Any,1,<:
     a = getindex_value(r1) * getindex_value(r2)
     a:a:∞
 end
+
+
+###
+# MemoryLayout
+####
+
+MemoryLayout(::Type{<:AbstractInfUnitRange}) = LazyLayout()
+MemoryLayout(::Type{<:InfStepRange}) = LazyLayout()

test/runtests.jl

@@ -1,7 +1,7 @@
-using LinearAlgebra, SparseArrays, InfiniteArrays, FillArrays, LazyArrays, Statistics, DSP, Test
+using LinearAlgebra, SparseArrays, InfiniteArrays, FillArrays, LazyArrays, Statistics, DSP, BandedMatrices, Test
 import InfiniteArrays: OrientedInfinity, OneToInf, InfUnitRange, InfStepRange
-import LazyArrays: CachedArray
-
+import LazyArrays: CachedArray, MemoryLayout, LazyLayout
+import BandedMatrices: _BandedMatrix, BandedColumns
 
 @testset "∞" begin
     @test ∞ ≠ 1
@@ -420,6 +420,8 @@ end
     @test D[1:10,1:10] == Diagonal(1:10)
     @test_broken D^2 isa Diagonal
     @test D*D isa Diagonal
+    @test MemoryLayout(typeof(D.diag)) == LazyLayout()
+    @test MemoryLayout(typeof(D)) == LazyLayout()
     @test Ones(∞,∞)*D isa ApplyArray
     @test (Ones(∞,∞)*D)[1:10,1:10] == Ones(10,10)*D[1:10,1:10]
 end
@@ -540,8 +542,8 @@ end
     @test diff(x[1:10]) == diff(x)[1:9]
     @test diff(y)[1:20] == x[2:21]
 
-    @test cumsum(x).arrays[2] ≡ 8:12
-    @test last(y.arrays) == sum(x[1:9]):2:∞
+    @test cumsum(x).args[2] ≡ 8:12
+    @test last(y.args) == sum(x[1:9]):2:∞
     r = (3:4:∞)
     @test cumsum(r)[1:20] == cumsum(r[1:20])
 end
@@ -596,6 +598,24 @@ end
     @test size(A*B) == (3,∞)
     @test (A*B)[1:3,1:10] == Fill(1,3,10)*Diagonal(1:10)
 
-    @test_broken A*B*C isa ApplyArray
+    @test A*B*C isa ApplyArray
+    @test size(A*B*C) == (3,)
+    @test (A*B*C)[1] == 14
+    @test A*B*C == fill(14,3)
+    @test_throws BoundsError (A*B*C)[1:10,1:10]
     @test A*B*D isa ApplyArray
+    @test (A*B*D)[1:3,1:5] == fill(6.0,3,5)
+end
+
+@testset "MemoryLayout" begin
+    @test MemoryLayout(OneToInf{Int}) == LazyLayout()
+    @test MemoryLayout(typeof((0:∞))) == LazyLayout()
+    @test MemoryLayout(typeof((0:∞)')) == LazyLayout()
+    A = _BandedMatrix((0:∞)', ∞, -1, 1)
+    @test MemoryLayout(typeof(A)) == BandedColumns{LazyLayout}()
+end
+
+@testset "Banded" begin
+    A = _BandedMatrix((0:∞)', ∞, -1, 1)
+    @test_broken apply(*, Eye(∞), A) ≡ A
 end