increase coverage

Author: dlfivefifty

src/InfiniteLinearAlgebra.jl

@@ -40,7 +40,7 @@ import LazyArrays: AbstractCachedMatrix, AbstractCachedVector, AbstractLazyLayou
                    CachedArray, CachedLayout, CachedMatrix, CachedVector, LazyArrayStyle, LazyLayout,
                    LazyLayouts, LazyMatrix, LazyVector, AbstractPaddedLayout, PaddedColumns, _broadcast_sub_arguments,
                    applybroadcaststyle, applylayout, arguments, cacheddata, paddeddata, resizedata!, simplifiable,
-                   simplify, islazy, islazy_layout, cache_getindex, cache_layout
+                   simplify, islazy, islazy_layout, cache_getindex, cache_layout, AbstractInvLayout
 
 import LazyBandedMatrices: AbstractLazyBandedBlockBandedLayout, AbstractLazyBandedLayout, AbstractLazyBlockBandedLayout, ApplyBandedLayout, BlockVec,
                            BroadcastBandedLayout, KronTravBandedBlockBandedLayout, LazyBandedLayout,

src/infcholesky.jl

@@ -23,9 +23,10 @@ struct AdaptiveCholeskyFactorsBlockBandedLayout <: AbstractLazyBlockBandedLayout
 
 const AdaptiveCholeskyFactorsLayouts = Union{AdaptiveCholeskyFactorsLayout,AdaptiveCholeskyFactorsBandedLayout,AdaptiveCholeskyFactorsBlockBandedLayout}
 
-adaptivecholeskyfactorslayout(_) = AdaptiveCholeskyFactorsLayout()
+# TODO: support other than Banded
+# adaptivecholeskyfactorslayout(_) = AdaptiveCholeskyFactorsLayout()
 adaptivecholeskyfactorslayout(::BandedLayouts) = AdaptiveCholeskyFactorsBandedLayout()
-adaptivecholeskyfactorslayout(::BlockBandedLayouts) = AdaptiveCholeskyFactorsBlockBandedLayout()
+# adaptivecholeskyfactorslayout(::BlockBandedLayouts) = AdaptiveCholeskyFactorsBlockBandedLayout()
 
 
 MemoryLayout(::Type{AdaptiveCholeskyFactors{T,DM}}) where {T,DM} = adaptivecholeskyfactorslayout(MemoryLayout(DM))

src/infqr.jl

@@ -106,7 +106,7 @@ adaptiveqrfactorslayout(::BlockBandedLayouts) = AdaptiveQRFactorsBlockBandedLayo
 
 MemoryLayout(::Type{AdaptiveQRFactors{T,DM}}) where {T,DM} =adaptiveqrfactorslayout(MemoryLayout(DM))
 triangularlayout(::Type{Tri}, ::ML) where {Tri, ML<:AdaptiveQRFactorsLayouts} = Tri{ML}()
-transposelayout(A::AdaptiveQRFactorsLayouts) = A
+# transposelayout(A::AdaptiveQRFactorsLayouts) = A
 
 size(F::AdaptiveQRFactors) = size(F.data.data)
 axes(F::AdaptiveQRFactors) = axes(F.data.data)
@@ -174,7 +174,7 @@ factorize_layout(::BandedLayouts, ::NTuple{2,OneToInf{Int}}, A) = qr(A)
 factorize_layout(::AbstractBandedLayout, ::NTuple{2,OneToInf{Int}}, A) = qr(A)
 
 
-cache_layout(::TriangularLayout{UPLO, UNIT, <:AdaptiveQRFactorsLayouts}, A::AbstractMatrix) where {UPLO, UNIT} = A # already cached
+cache_layout(::TriangularLayout{'U', 'N', AdaptiveQRFactorsBandedLayout}, A::AbstractMatrix) = A # already cached
 
 partialqr!(F::QR, n) = partialqr!(F.factors, n)
 partialqr!(F::AdaptiveQRFactors, n) = partialqr!(F.data, n)
@@ -382,6 +382,7 @@ simplifiable(M::Mul{<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts},<:QRPackedQLay
 simplifiable(M::Mul{<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts},<:LazyLayouts}) = Val(false)
 simplifiable(M::Mul{<:Any,<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts}}) = Val(false)
 simplifiable(M::Mul{<:LazyLayouts,<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts}}) = Val(false)
+simplifiable(M::Mul{<:AbstractInvLayout,<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts}}) = Val(false)
 
 
 copy(M::Mul{<:QRPackedQLayout{<:AdaptiveQRFactorsLayouts}, <:QRPackedQLayout{<:AdaptiveQRFactorsLayouts}}) = simplify(M)

test/test_infqr.jl

@@ -1,6 +1,6 @@
 using InfiniteLinearAlgebra, LinearAlgebra, BandedMatrices, InfiniteArrays, MatrixFactorizations, LazyArrays,
         FillArrays, SpecialFunctions, Test, SemiseparableMatrices, LazyBandedMatrices, BlockArrays, BlockBandedMatrices, ArrayLayouts
-import LazyArrays: colsupport, rowsupport, MemoryLayout, DenseColumnMajor, TriangularLayout, resizedata!, arguments
+import LazyArrays: colsupport, rowsupport, MemoryLayout, DenseColumnMajor, TriangularLayout, resizedata!, arguments, simplifiable
 import LazyBandedMatrices: BroadcastBandedLayout, InvDiagTrav, BroadcastBandedBlockBandedLayout
 import BandedMatrices: _BandedMatrix, _banded_qr!, BandedColumns
 import InfiniteLinearAlgebra: partialqr!, AdaptiveQRData, AdaptiveQRFactorsBandedLayout, adaptiveqr
@@ -165,6 +165,29 @@ import SemiseparableMatrices: AlmostBandedLayout, VcatAlmostBandedLayout
             @test F\b ≈ F\view(b,:)
             @test_broken F\b ≈ ldiv!(F, view(copy(b),:))
         end
+
+        @testset "cache/mul" begin
+            A = _BandedMatrix(Vcat(Ones(1,∞), (1:∞)', Ones(1,∞)), ℵ₀, 1, 1)
+            Q,R = qr(A)
+            @test cache(R) ≡ R
+
+            @test simplifiable(*, R, A) == Val(false)
+            @test simplifiable(*, A, R) == Val(false)
+            @test simplifiable(*, parent(R), A) == Val(false)
+            @test simplifiable(*, A, parent(R)) == Val(false)
+            @test simplifiable(*, inv(R), A) == Val(false)
+            @test simplifiable(*, A, inv(R)) == Val(false)
+            @test simplifiable(*, inv(R), Q) == Val(false)
+            @test simplifiable(*, Q, inv(R)) == Val(false)
+            @test simplifiable(*, Symmetric(inv(R)), Q) == Val(false)
+            @test simplifiable(*, Q, Symmetric(inv(R))) == Val(false)
+            @test (R * A)[1:10,1:10] ≈ R[1:10,1:11] * A[1:11,1:10]
+            @test (Q * A)[1:10,1:10] ≈ Q[1:10,1:11] * A[1:11,1:10]
+            @test mul(Q, Symmetric(inv(R))) isa ApplyArray # several bugs avoided heree
+            @test mul(Symmetric(inv(R)), Q) isa ApplyArray # several bugs avoided heree
+            @test (parent(R) * A)[1:10,1:10] ≈ parent(R)[1:10,1:11] * A[1:11,1:10]
+
+        end
     end
 
     @testset "almost-banded" begin