Make AdaptiveLayout lazy (#144)

* Make AdaptiveLayout lazy

* Update test_infql.jl

* Update infqr.jl

* add tests and update packages

* Update infqr.jl

* use LazyLayouts

* increase coverage

* Don't test on v1.10 yet

Author: dlfivefifty

.github/workflows/ci.yml

@@ -24,7 +24,6 @@ jobs:
         version:
           - '1.6'
           - '1'
-          - '~1.10.0-0'
         os:
           - ubuntu-latest
           - macOS-latest

Project.toml

@@ -1,6 +1,6 @@
 name = "InfiniteLinearAlgebra"
 uuid = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
-version = "0.6.21"
+version = "0.6.22"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -18,16 +18,16 @@ SemiseparableMatrices = "f8ebbe35-cbfb-4060-bf7f-b10e4670cf57"
 
 [compat]
 Aqua = "0.6"
-ArrayLayouts = "0.8.16, 1"
+ArrayLayouts = "1.0.12"
 BandedMatrices = "0.17.19"
 BlockArrays = "0.16.14"
-BlockBandedMatrices = "0.11.5, 0.12"
+BlockBandedMatrices = "0.12"
 DSP = "0.7"
-FillArrays = "0.13, 1"
+FillArrays = "1"
 InfiniteArrays = "0.12"
-LazyArrays = "1.1.1"
+LazyArrays = "1.3"
 LazyBandedMatrices = "0.8.7"
-MatrixFactorizations = "0.9.6, 1, 2"
+MatrixFactorizations = "1, 2"
 SemiseparableMatrices = "0.3"
 julia = "1.6"
 

src/InfiniteLinearAlgebra.jl

@@ -18,10 +18,10 @@ import FillArrays: AbstractFill, getindex_value, axes_print_matrix_row
 import InfiniteArrays: OneToInf, InfUnitRange, Infinity, PosInfinity, InfiniteCardinal, InfStepRange, AbstractInfUnitRange, InfAxes, InfRanges
 import LinearAlgebra: matprod, qr, AbstractTriangular, AbstractQ, adjoint, transpose, AdjOrTrans
 import LazyArrays: applybroadcaststyle, CachedArray, CachedMatrix, CachedVector, DenseColumnMajor, FillLayout, ApplyMatrix, check_mul_axes, LazyArrayStyle,
-                    resizedata!, MemoryLayout,
+                    resizedata!, MemoryLayout, AbstractLazyLayout,
                     factorize, sub_materialize, LazyLayout, LazyArrayStyle, layout_getindex,
                     applylayout, ApplyLayout, PaddedLayout, CachedLayout, AbstractCachedVector, AbstractCachedMatrix, cacheddata, zero!, MulAddStyle, ApplyArray,
-                    LazyArray, LazyMatrix, LazyVector, paddeddata, arguments, resizedata!
+                    LazyArray, LazyMatrix, LazyVector, paddeddata, arguments, resizedata!, simplifiable, simplify, LazyLayouts
 import MatrixFactorizations: ul, ul!, _ul, ql, ql!, _ql, QLPackedQ, getL, getR, getQ, getU, reflector!, reflectorApply!, QL, QR, QRPackedQ,
                             QRPackedQLayout, AdjQRPackedQLayout, QLPackedQLayout, AdjQLPackedQLayout, LayoutQ
 

src/infcholesky.jl

@@ -1,5 +1,5 @@
 
-mutable struct AdaptiveCholeskyFactors{T,DM<:AbstractMatrix{T},M<:AbstractMatrix{T}} <: LayoutMatrix{T}
+mutable struct AdaptiveCholeskyFactors{T,DM<:AbstractMatrix{T},M<:AbstractMatrix{T}} <: LazyMatrix{T}
     data::CachedMatrix{T,DM,M}
     ncols::Int
 end
@@ -50,6 +50,9 @@ adaptivecholesky(A) = Cholesky(AdaptiveCholeskyFactors(A), :U, 0)
 ArrayLayouts._cholesky(::SymTridiagonalLayout, ::NTuple{2,OneToInf{Int}}, A, ::CNoPivot) = adaptivecholesky(A)
 ArrayLayouts._cholesky(::SymmetricLayout{<:AbstractBandedLayout}, ::NTuple{2,OneToInf{Int}}, A, ::CNoPivot) = adaptivecholesky(A)
 
+colsupport(::AdaptiveCholeskyFactors, ::OneToInf) = OneToInf()
+rowsupport(::AdaptiveCholeskyFactors, ::OneToInf) = OneToInf()
+
 function colsupport(F::AdaptiveCholeskyFactors, j)
     partialcholesky!(F, maximum(j)+bandwidth(F,2))
     colsupport(F.data.data, j)

src/infqr.jl

@@ -92,7 +92,7 @@ struct AdaptiveQRFactors{T,DM<:AbstractMatrix{T},M<:AbstractMatrix{T}} <: Layout
     data::AdaptiveQRData{T,DM,M}
 end
 
-struct AdaptiveLayout{M} <: MemoryLayout end
+struct AdaptiveLayout{M} <: AbstractLazyLayout end
 MemoryLayout(::Type{AdaptiveQRFactors{T,DM,M}}) where {T,DM,M} = AdaptiveLayout{typeof(MemoryLayout(DM))}()
 triangularlayout(::Type{Tri}, ::ML) where {Tri, ML<:AdaptiveLayout} = Tri{ML}()
 transposelayout(A::AdaptiveLayout{ML}) where ML = AdaptiveLayout{typeof(transposelayout(ML()))}()
@@ -356,5 +356,15 @@ ldiv!(F::QR{<:Any,<:AdaptiveQRFactors}, b::LayoutVector; kwds...) = ldiv!(F.R, l
 factorize(A::BandedMatrix{<:Any,<:Any,<:OneToInf}) = qr(A)
 qr(A::SymTridiagonal{T,<:AbstractFill{T,1,Tuple{OneToInf{Int}}}}) where T = adaptiveqr(A)
 
-copy(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout}}) = ApplyArray(*, M.A, M.B)
-copy(M::Mul{<:Any,<:QRPackedQLayout{<:AdaptiveLayout}}) = ApplyArray(*, M.A, M.B)
+simplifiable(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout}}) = Val(false)
+simplifiable(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout},<:QRPackedQLayout{<:AdaptiveLayout}}) = Val(false)
+simplifiable(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout},<:LazyLayouts}) = Val(false)
+simplifiable(M::Mul{<:Any,<:QRPackedQLayout{<:AdaptiveLayout}}) = Val(false)
+simplifiable(M::Mul{<:LazyLayouts,<:QRPackedQLayout{<:AdaptiveLayout}}) = Val(false)
+
+
+copy(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout},<:QRPackedQLayout{<:AdaptiveLayout}}) = simplify(M)
+copy(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout}}) = simplify(M)
+copy(M::Mul{<:QRPackedQLayout{<:AdaptiveLayout},<:LazyLayouts}) = simplify(M)
+copy(M::Mul{<:Any,<:QRPackedQLayout{<:AdaptiveLayout}}) = simplify(M)
+copy(M::Mul{<:LazyLayouts,<:QRPackedQLayout{<:AdaptiveLayout}}) = simplify(M)

test/test_infcholesky.jl

@@ -35,4 +35,14 @@ import InfiniteLinearAlgebra: SymmetricBandedLayouts
 
         @test cholesky(S^2).U[1:100,1:100] ≈ cholesky(Symmetric((S^2)[1:100,1:100])).U
     end
+
+    @testset "row/colsupport" begin
+        S = Symmetric(BandedMatrix(0 => 1:∞, 2 => Ones(∞)))
+        F = cholesky(S)
+        @test colsupport(F.factors,5) == rowsupport(F.factors,3) == 3:5
+        @test rowsupport(F.factors) == colsupport(F.factors) == axes(F.factors,1)
+
+        @test (F.U * F.U')[1:10,1:10]  ≈ F.U[1:10,1:12] * F.U[1:10,1:12]'
+        @test (F.U' * F.U)[1:10,1:10]  ≈ S[1:10,1:10]
+    end
 end

test/test_infql.jl

@@ -207,8 +207,8 @@ using ArrayLayouts: TriangularLayout, UnknownLayout
             A = _BandedMatrix(Vcat(2*Ones(1,∞), ((1 ./(1:∞)).+1/4)', Ones(1,∞)./3), ℵ₀, 1, 1)
             Q, L = ql(A)
             b = [[1, 2, 3]; zeros(∞)]
-            @test MemoryLayout(L) == TriangularLayout{'L', 'N', UnknownLayout}()
-            @test MemoryLayout(L') == TriangularLayout{'U', 'N', UnknownLayout}()
+            @test MemoryLayout(L) isa TriangularLayout{'L', 'N'}
+            @test MemoryLayout(L') isa TriangularLayout{'U', 'N'}
             @test (Q'*b)[1:2] == ApplyArray(*,Q',b)[1:2] == [-0.,-1.]
             @test (L*b)[1:6] == ApplyArray(*,L,b)[1:6] == [0. , -5.25,  -7.833333333333333, -2.4166666666666666, -1., 0.]
             @test size(ql(A).τ) == (ℵ₀, )

test/test_infqr.jl

@@ -1,5 +1,5 @@
 using InfiniteLinearAlgebra, LinearAlgebra, BandedMatrices, InfiniteArrays, MatrixFactorizations, LazyArrays,
-        FillArrays, SpecialFunctions, Test, SemiseparableMatrices, LazyBandedMatrices, BlockArrays
+        FillArrays, SpecialFunctions, Test, SemiseparableMatrices, LazyBandedMatrices, BlockArrays, BlockBandedMatrices, ArrayLayouts
 import LazyArrays: colsupport, rowsupport, MemoryLayout, DenseColumnMajor, TriangularLayout, resizedata!, arguments
 import LazyBandedMatrices: BroadcastBandedLayout, InvDiagTrav, BroadcastBandedBlockBandedLayout
 import BandedMatrices: _BandedMatrix, _banded_qr!, BandedColumns
@@ -309,4 +309,15 @@ import SemiseparableMatrices: AlmostBandedLayout, VcatAlmostBandedLayout
         u = \(A, [1; zeros(∞)]; tolerance=1E-8)
         @test A*u ≈ [1; zeros(∞)]
     end
+
+    @testset "lazy mul" begin
+        A = BandedMatrix(1 => Ones(∞), 0 => Fill(-2,∞), -1 => Ones(∞))
+        Q,R = qr(A)
+        @test (Q*R)[1:10,1:10] ≈ A[1:10,1:10]
+        @test (Q*Q)[1:10,1:10] ≈ Q[1:10,1:11]Q[1:11,1:10]
+        # MatrixFactorizations currently catches * so this is temporary to
+        # increase coverage
+        @test mul(Q, Ones(∞,∞)) isa ApplyArray
+        @test mul(Ones(∞,∞), Q) isa ApplyArray
+    end
 end