BlockArrays v1.0 and LazyArrays v2.0 (#186)

* Support LazyArrays v2.0

* Update test_odes.jl

* Update test_normalized.jl

* Fix padded

* tests pass

* Julia v1.10

* Update ci.yml

* Update documentation.yml

Author: dlfivefifty

.github/workflows/ci.yml

@@ -20,8 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.9'
-          - '1'
+          - '1.10'
         os:
           - ubuntu-latest
           - macOS-latest
@@ -49,4 +48,5 @@ jobs:
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v4
         with:
-          file: lcov.info
+          token: ${{ secrets.CODECOV_TOKEN }}
+          file: lcov.info

.github/workflows/documentation.yml

@@ -16,9 +16,9 @@ jobs:
       - uses: actions/checkout@v4
       - uses: julia-actions/setup-julia@v1
         with:
-          version: '1.9'
+          version: '1.10'
       - name: Install dependencies
-        run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
+        run: julia --project=docs/ -e 'using Pkg; Pkg.update(); Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
       - name: Build and deploy
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # If authenticating with GitHub Actions token

Project.toml

@@ -26,24 +26,24 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 
 [compat]
 ArrayLayouts = "1.3.1"
-BandedMatrices = "0.17.17, 1"
-BlockArrays = "0.16.9"
-BlockBandedMatrices = "0.12"
-ContinuumArrays = "0.17.3"
+BandedMatrices = "1"
+BlockArrays = "1"
+BlockBandedMatrices = "0.13"
+ContinuumArrays = "0.18"
 DomainSets = "0.6, 0.7"
 FFTW = "1.1"
-FastGaussQuadrature = "0.5, 1"
+FastGaussQuadrature = "1"
 FastTransforms = "0.15.15, 0.16"
 FillArrays = "1"
 HypergeometricFunctions = "0.3.4"
-InfiniteArrays = "0.12.11, 0.13"
-InfiniteLinearAlgebra = "0.6.16, 0.7"
+InfiniteArrays = " 0.14"
+InfiniteLinearAlgebra = "0.8"
 IntervalSets = "0.7"
-LazyArrays = "1.0.1"
-LazyBandedMatrices = "0.8.5, 0.9"
+LazyArrays = "2"
+LazyBandedMatrices = "0.10"
 QuasiArrays = "0.11"
 SpecialFunctions = "1.0, 2"
-julia = "1.9"
+julia = "1.10"
 
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/ClassicalOrthogonalPolynomials.jl

@@ -14,7 +14,7 @@ import Base: @_inline_meta, axes, getindex, unsafe_getindex, convert, prod, *, /
                 findall, searchsortedfirst, diff
 import Base.Broadcast: materialize, BroadcastStyle, broadcasted, Broadcasted
 import LazyArrays: MemoryLayout, Applied, ApplyStyle, flatten, _flatten, adjointlayout,
-                sub_materialize, arguments, sub_paddeddata, paddeddata, PaddedLayout, resizedata!, LazyVector, ApplyLayout, call,
+                sub_materialize, arguments, sub_paddeddata, paddeddata, AbstractPaddedLayout, PaddedColumns, resizedata!, LazyVector, ApplyLayout, call,
                 _mul_arguments, CachedVector, CachedMatrix, LazyVector, LazyMatrix, axpy!, AbstractLazyLayout, BroadcastLayout,
                 AbstractCachedVector, AbstractCachedMatrix, paddeddata, cache_filldata!,
                 simplifiable, PaddedArray, converteltype, simplify

src/adaptivetransform.jl

@@ -8,15 +8,15 @@ padchop!(cfs, tol, ax...) = pad(chop!(cfs, tol), ax...)
 padchop(cfs, tol, ax...) = pad(chop(cfs, tol), ax...)
 
 # ax will impose block structure for us
-padchop!(cfs::PseudoBlockVector, tol, ax...) = padchop!(cfs.blocks, tol, ax...)
+padchop!(cfs::BlockedVector, tol, ax...) = padchop!(cfs.blocks, tol, ax...)
 
 
 padresize!(cfs, m, ax...) = pad(compatible_resize!(cfs, m), ax...)
-padresize!(cfs::PseudoBlockVector, m, ax...) = padresize!(cfs.blocks, m, ax...)
+padresize!(cfs::BlockedVector, m, ax...) = padresize!(cfs.blocks, m, ax...)
 
 
 increasingtruncations(::OneToInf) = oneto.(2 .^ (4:∞))
-increasingtruncations(::BlockedUnitRange) = broadcast(n -> Block.(oneto(n)), (2 .^ (4:∞)))
+increasingtruncations(::BlockedOneTo) = broadcast(n -> Block.(oneto(n)), (2 .^ (4:∞)))
 
 
 function adaptivetransform_ldiv(A::AbstractQuasiArray{U}, f::AbstractQuasiVector{V}) where {U,V}

src/classical/fourier.jl

@@ -9,7 +9,7 @@ Laurent() = Laurent{ComplexF64}()
 ==(::Fourier, ::Fourier) = true
 ==(::Laurent, ::Laurent) = true
 
-axes(F::AbstractFourier) = (Inclusion(ℝ), _BlockedUnitRange(1:2:∞))
+axes(F::AbstractFourier) = (Inclusion(ℝ), BlockedOneTo(1:2:∞))
 
 function getindex(F::Fourier{T}, x::Real, j::Int)::T where T
     isodd(j) && return cos((j÷2)*x)
@@ -139,7 +139,7 @@ import BlockBandedMatrices: _BlockSkylineMatrix
 
 @simplify function *(A::QuasiAdjoint{<:Any,<:Fourier}, B::Fourier)
     TV = promote_type(eltype(A),eltype(B))
-    PseudoBlockArray(Diagonal(Vcat(2convert(TV,π),Fill(convert(TV,π),∞))), (axes(A,1),axes(B,2)))
+    BlockedArray(Diagonal(Vcat(2convert(TV,π),Fill(convert(TV,π),∞))), (axes(A,1),axes(B,2)))
 end
 
 @simplify function *(A::QuasiAdjoint{<:Any,<:Laurent}, B::Laurent)
@@ -153,7 +153,7 @@ function diff(F::Fourier{T}; dims=1) where T
 end
 
 function diff(F::Laurent{T}; dims=1) where T
-    D = Diagonal(PseudoBlockVector((((one(real(T)):∞) .÷ 2) .* (1 .- 2 .* iseven.(1:∞))) * convert(T,im), (axes(F,2),)))
+    D = Diagonal(BlockedVector((((one(real(T)):∞) .÷ 2) .* (1 .- 2 .* iseven.(1:∞))) * convert(T,im), (axes(F,2),)))
     F * D
 end
 

src/clenshaw.jl

@@ -100,22 +100,22 @@ end
 # Clenshaw
 ###
 
-function unsafe_getindex(f::Mul{<:AbstractOPLayout,<:PaddedLayout}, x::Number)
+function unsafe_getindex(f::Mul{<:AbstractOPLayout,<:AbstractPaddedLayout}, x::Number)
     P,c = f.A,f.B
     _p0(P)*clenshaw(paddeddata(c), recurrencecoefficients(P)..., x)
 end
 
-function unsafe_getindex(f::Mul{<:AbstractOPLayout,<:PaddedLayout}, x::Number, jr)
+function unsafe_getindex(f::Mul{<:AbstractOPLayout,<:AbstractPaddedLayout}, x::Number, jr)
     P,c = f.A,f.B
     _p0(P)*clenshaw(view(paddeddata(c),:,jr), recurrencecoefficients(P)..., x)
 end
 
-Base.@propagate_inbounds function getindex(f::Mul{<:AbstractOPLayout,<:PaddedLayout}, x::Number, j...)
+Base.@propagate_inbounds function getindex(f::Mul{<:AbstractOPLayout,<:AbstractPaddedLayout}, x::Number, j...)
     @inbounds checkbounds(ApplyQuasiArray(*,f.A,f.B), x, j...)
     unsafe_getindex(f, x, j...)
 end
 
-Base.@propagate_inbounds getindex(f::Mul{<:WeightedOPLayout,<:PaddedLayout}, x::Number, j...) =
+Base.@propagate_inbounds getindex(f::Mul{<:WeightedOPLayout,<:AbstractPaddedLayout}, x::Number, j...) =
     weight(f.A)[x] * (unweighted(f.A) * f.B)[x, j...]
 
 ###
@@ -324,7 +324,7 @@ transposelayout(M::ClenshawLayout) = LazyBandedMatrices.LazyBandedLayout()
 Base.permutedims(M::Clenshaw{<:Number}) = transpose(M)
 
 
-function materialize!(M::MatMulVecAdd{<:ClenshawLayout,<:PaddedLayout,<:PaddedLayout})
+function materialize!(M::MatMulVecAdd{<:ClenshawLayout,<:AbstractPaddedLayout,<:AbstractPaddedLayout})
     α,A,x,β,y = M.α,M.A,M.B,M.β,M.C
     length(y) == size(A,1) || throw(DimensionMismatch("Dimensions must match"))
     length(x) == size(A,2) || throw(DimensionMismatch("Dimensions must match"))

src/interlace.jl

@@ -154,7 +154,7 @@ axes(A::SetindexInterlace) = (union(axes.(A.args,1)...), LazyBandedMatrices._blo
 
 ArrayLayouts.zeroeltype(M::Mul{<:Any,<:Any,<:SetindexInterlace}) = convert(eltype(M),M.A.z)
 
-function getindex(f::Mul{BasisLayout,<:PaddedLayout,<:SetindexInterlace{<:Any,<:AbstractFill}}, x::Number)
+function getindex(f::Mul{BasisLayout,<:AbstractPaddedLayout,<:SetindexInterlace{<:Any,<:AbstractFill}}, x::Number)
     P = getindex_value(f.A.args)
     d = length(f.A.args)
     X = reshape(paddeddata(f.B),d,:)

src/lanczos.jl

@@ -91,13 +91,13 @@ Base.BroadcastStyle(::Type{<:LanczosConversion}) = LazyArrays.LazyArrayStyle{2}(
 
 struct LanczosConversionLayout <: AbstractLazyLayout end
 
-LazyArrays.simplifiable(::Mul{LanczosConversionLayout,<:PaddedLayout}) = Val(true)
-function copy(M::Mul{LanczosConversionLayout,<:PaddedLayout})
+LazyArrays.simplifiable(::Mul{LanczosConversionLayout,<:AbstractPaddedLayout}) = Val(true)
+function copy(M::Mul{LanczosConversionLayout,<:AbstractPaddedLayout})
     resizedata!(M.A.data, maximum(colsupport(M.B)))
     M.A.data.R * M.B
 end
 
-function copy(M::Ldiv{LanczosConversionLayout,<:PaddedLayout})
+function copy(M::Ldiv{LanczosConversionLayout,<:AbstractPaddedLayout})
     resizedata!(M.A.data, maximum(colsupport(M.B)))
     M.A.data.R \ M.B
 end
@@ -110,7 +110,7 @@ end
 MemoryLayout(::Type{<:LanczosConversion}) = LanczosConversionLayout()
 triangulardata(R::LanczosConversion) = R
 sublayout(::LanczosConversionLayout, ::Type{<:Tuple{KR,Integer}}) where KR = 
-    sublayout(PaddedLayout{UnknownLayout}(), Tuple{KR})
+    sublayout(PaddedColumns{UnknownLayout}(), Tuple{KR})
 
 function sub_paddeddata(::LanczosConversionLayout, S::SubArray{<:Any,1,<:AbstractMatrix,<:Tuple{Any,Integer}})
     P = parent(S)

test/test_fourier.jl

@@ -43,16 +43,16 @@ import QuasiArrays: MulQuasiArray
 
         @test F == F
 
-        @test axes(F,2) isa BlockedUnitRange{InfiniteArrays.InfStepRange{Int,Int}}
-        @test axes(F) isa Tuple{<:Inclusion,BlockedUnitRange{InfiniteArrays.InfStepRange{Int,Int}}}
+        @test axes(F,2) isa BlockedOneTo{Int,InfiniteArrays.InfStepRange{Int,Int}}
+        @test axes(F) isa Tuple{<:Inclusion,BlockedOneTo{Int,InfiniteArrays.InfStepRange{Int,Int}}}
         @test axes(F,2)[Block(2)] == 2:3
         @test F[0.1,1] == 1.0
         @test F[0.1,2] == sin(0.1)
         @test F[0.1,1:4] == [1,sin(0.1),cos(0.1),sin(2*0.1)]
         @test F[0.1,Block(4)] == [sin(3*0.1),cos(3*0.1)]
         @test F[0.1,Block.(1:3)] == [1,sin(0.1),cos(0.1),sin(2*0.1),cos(2*0.1)]
 
-        u = F * PseudoBlockVector([[1,2,3]; zeros(∞)], (axes(F,2),));
+        u = F * BlockedVector([[1,2,3]; zeros(∞)], (axes(F,2),));
         @test u[0.1] == 1 + 2sin(0.1) + 3cos(0.1)
     end
 
@@ -84,7 +84,7 @@ import QuasiArrays: MulQuasiArray
         @test (F\F)*D̃ isa BlockArray
         @test (F \ (D*F))[Block.(1:3),Block.(1:3)] == [0 0 0 0 0; 0 0.0 -1 0 0; 0 1 0 0 0; 0 0 0 0 -2; 0 0 0 2 0]
 
-        u = F * PseudoBlockVector([[1,2,3,4,5]; zeros(∞)], (axes(F,2),));
+        u = F * BlockedVector([[1,2,3,4,5]; zeros(∞)], (axes(F,2),));
         @test blockisequal(axes(D̃,2),axes(u.args[2],1))
         @test (D*u)[0.1] ≈ 2cos(0.1) - 3sin(0.1) + 8cos(2*0.1) - 10sin(2*0.1)
     end
@@ -134,16 +134,16 @@ end
 
         @test F == F
 
-        @test axes(F,2) isa BlockedUnitRange{InfiniteArrays.InfStepRange{Int,Int}}
-        @test axes(F) isa Tuple{<:Inclusion,BlockedUnitRange{InfiniteArrays.InfStepRange{Int,Int}}}
+        @test axes(F,2) isa BlockedOneTo{Int,InfiniteArrays.InfStepRange{Int,Int}}
+        @test axes(F) isa Tuple{<:Inclusion,BlockedOneTo{Int,InfiniteArrays.InfStepRange{Int,Int}}}
         @test axes(F,2)[Block(2)] == 2:3
         @test F[0.1,1] ≡ complex(1.0)
         @test F[0.1,2] == exp(-im*0.1)
         @test F[0.1,1:4] == [1,exp(-im*0.1),exp(im*0.1),exp(-2im*0.1)]
         @test F[0.1,Block(4)] == [exp(-im*3*0.1),exp(im*3*0.1)]
         @test F[0.1,Block.(1:3)] == [1,exp(-im*0.1),exp(im*0.1),exp(-2im*0.1),exp(2im*0.1)]
 
-        u = F * PseudoBlockVector([[1,2,3]; zeros(∞)], (axes(F,2),));
+        u = F * BlockedVector([[1,2,3]; zeros(∞)], (axes(F,2),));
         @test u[0.1] == 1 + 2exp(-im*0.1) + 3exp(im*0.1)
     end
 
@@ -175,7 +175,7 @@ end
         @test (F\F)*D̃ isa Diagonal
         @test (F \ (D*F))[Block.(1:3),Block.(1:3)] == Diagonal([0,-im,im,-2im,2im])
 
-        u = F * PseudoBlockVector([[1,2,3,4,5]; zeros(∞)], (axes(F,2),));
+        u = F * BlockedVector([[1,2,3,4,5]; zeros(∞)], (axes(F,2),));
         @test blockisequal(axes(D̃,2),axes(u.args[2],1))
         @test (D*u)[0.1] ≈ -2im*exp(-im*0.1) + 3im*exp(im*0.1) - 8im*exp(-im*2*0.1) + 10im*exp(im*2*0.1)
     end