Generalise cached banded matrix (#361)

* Generalise cached banded matrix

* update tests

* v2.5

Project.toml

@@ -1,6 +1,6 @@
 name = "LazyArrays"
 uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02"
-version = "2.4"
+version = "2.5"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

ext/LazyArraysBandedMatricesExt.jl

@@ -11,7 +11,7 @@ import LazyArrays: sublayout, symmetriclayout, hermitianlayout, applylayout, cac
                    PaddedColumns, CachedArray, CachedMatrix, LazyLayout, BroadcastLayout, ApplyLayout,
                    paddeddata, resizedata!, broadcastlayout, _broadcastarray2broadcasted, _broadcast_sub_arguments,
                    arguments, call, applybroadcaststyle, simplify, simplifiable, islazy_layout, lazymaterialize, _broadcast_mul_mul, _broadcast_mul_simplifiable,
-                   triangularlayout, AbstractCachedMatrix, _mulbanded_copyto!, ApplyBandedLayout, BroadcastBandedLayout
+                   triangularlayout, AbstractCachedMatrix, cache_layout, _mulbanded_copyto!, ApplyBandedLayout, BroadcastBandedLayout
 import Base: BroadcastStyle, similar, copy, broadcasted, getindex, OneTo, oneto, tail, sign, abs
 import BandedMatrices: bandedbroadcaststyle, bandwidths, isbanded, bandedcolumns, bandeddata, BandedStyle,
                         AbstractBandedLayout, AbstractBandedMatrix, BandedColumns, BandedRows, BandedSubBandedMatrix, 
@@ -450,10 +450,11 @@ LazyArrays._vcat_sub_arguments(lay::ApplyBandedLayout{typeof(hcat)}, A, V) = Laz
 
 CachedArray(::Type{BandedMatrix}, matrix::AbstractMatrix{T}) where T = CachedArray(BandedMatrix{T}(undef, (0,0), bandwidths(matrix)), matrix)
 
-cachedlayout(::BandedColumns{DenseColumnMajor}, ::AbstractBandedLayout) = BandedColumns{DenseColumnMajor}()
 bandwidths(B::CachedMatrix) = bandwidths(B.data)
 isbanded(B::CachedMatrix) = isbanded(B.data)
 
+cache_layout(::BandedLayouts, A::AbstractMatrix{T}) where T = CachedArray(BandedMatrix{T}(undef, (0,0), bandwidths(A)), A)
+
 function bandeddata(A::CachedMatrix)
     resizedata!(A, size(A)...)
     bandeddata(A.data)

ext/LazyArraysBlockArraysExt.jl

@@ -7,7 +7,7 @@ using LazyArrays.FillArrays
 import LazyArrays: resizedata!, paddeddata, paddeddata_axes, arguments, call,
                     LazyArrayStyle, CachedVector, AbstractPaddedLayout, PaddedLayout, PaddedRows, PaddedColumns, BroadcastLayout,
                     AbstractCachedMatrix, AbstractCachedArray, setindex, applybroadcaststyle,
-                    ApplyLayout, _cache
+                    ApplyLayout, cache_layout
 import ArrayLayouts: sub_materialize
 import Base: getindex, BroadcastStyle, broadcasted, OneTo
 import BlockArrays: AbstractBlockStyle, AbstractBlockedUnitRange, blockcolsupport, blockrowsupport, BlockSlice, BlockIndexRange, AbstractBlockLayout

ext/LazyArraysBlockBandedMatricesExt.jl

@@ -9,7 +9,7 @@ using LazyArrays.ArrayLayouts
 import LazyArrays: sublayout, symmetriclayout, hermitianlayout, transposelayout, conjlayout,
                 PaddedLayout, PaddedColumns, AbstractPaddedLayout, PaddedRows, paddeddata,
                 islazy_layout, arguments, call, applylayout, broadcastlayout, applybroadcaststyle,
-                BroadcastMatrix, _broadcastarray2broadcasted, _cache, resizedata!, simplifiable,
+                BroadcastMatrix, _broadcastarray2broadcasted, cache_layout, resizedata!, simplifiable,
                 AbstractLazyLayout, LazyArrayStyle, LazyLayout, ApplyLayout, BroadcastLayout, AbstractInvLayout,
                 _mul_args_colsupport, _mul_args_rowsupport, _mat_mul_arguments, LazyBandedLayout,
                 CachedArray, _broadcast_sub_arguments, simplify, lazymaterialize, _mulbanded_copyto!
@@ -193,7 +193,7 @@ sublayout(LAY::BroadcastBandedBlockBandedLayout, ::Type{<:Tuple{BlockSlice{<:Blo
 _broadcastarray2broadcasted(::BroadcastBlockBandedLayouts{F}, A) where F = _broadcastarray2broadcasted(BroadcastLayout{F}(), A)
 _broadcastarray2broadcasted(::BroadcastBlockBandedLayouts{F}, A::BroadcastArray) where F = _broadcastarray2broadcasted(BroadcastLayout{F}(), A)
 
-function _cache(::BlockBandedLayouts, A::AbstractMatrix{T}) where T
+function cache_layout(::BlockBandedLayouts, A::AbstractMatrix{T}) where T
     kr,jr = axes(A)
     CachedArray(BlockBandedMatrix{T}(undef, (kr[Block.(1:0)], jr[Block.(1:0)]), blockbandwidths(A)), A)
 end

src/cache.jl

@@ -48,11 +48,14 @@ CachedArray(array::AbstractArray{T,N}) where {T,N} = CachedArray(similar(array,
 Caches the entries of an array.
 """
 cache(::Type{MT}, O::AbstractArray) where {MT<:AbstractArray} = CachedArray(MT,O)
-cache(A::AbstractArray) = _cache(MemoryLayout(A), A)
-_cache(_, O::AbstractArray) = CachedArray(O)
-_cache(_, O::CachedArray) = CachedArray(copy(O.data), O.array, O.datasize)
-_cache(::AbstractStridedLayout, O::AbstractArray) = copy(O)
 
+
+cache(A::AbstractArray) = cache_layout(MemoryLayout(A), A)
+cache_layout(_, O::AbstractArray) = CachedArray(O)
+cache_layout(_, O::CachedArray) = CachedArray(copy(O.data), O.array, O.datasize)
+cache_layout(::AbstractStridedLayout, O::AbstractArray) = copy(O)
+
+const _cache = cache_layout # TODO: deprecate
 cacheddata(A::AbstractCachedArray) = view(A.data,OneTo.(A.datasize)...)
 
 convert(::Type{AbstractArray{T}}, S::CachedArray{T}) where T = S
@@ -565,7 +568,7 @@ end
 # AbstractQ
 ##
 cache(A::AbstractQ) = _cache(MemoryLayout(A), A)
-_cache(_, O::AbstractQ) = CachedArray(O)
+cache_layout(_, O::AbstractQ) = CachedArray(O)
 CachedArray(array::AbstractQ{T}) where T = CachedArray(similar(Matrix{T}, (0,0)), array)
 CachedArray(data::AbstractMatrix, array::AbstractQ) = CachedArray(data, array, size(data))
 CachedArray(data::AbstractMatrix{T}, array::AbstractQ{T}, datasize::NTuple{2,Int}) where T =

test/bandedtests.jl

@@ -773,7 +773,7 @@ LinearAlgebra.lmul!(β::Number, A::PseudoBandedMatrix) = (lmul!(β, A.data); A)
     @testset "cache" begin
         B = brand(10,10,2,1)
         A = ApplyArray(*, B, B)
-        @test_broken cache(A).data isa BandedMatrix
+        @test cache(A).data isa BandedMatrix
         C = cache(BandedMatrix,A)
         @test isbanded(C)
         @test bandwidths(C) == (4,2)