Move LazyArrays (#8)

* Update Project.toml

* Update Project.toml

* Tests pass!

* Update Project.toml

Author: dlfivefifty

Project.toml

@@ -3,23 +3,27 @@ uuid = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
 version = "0.0.2"
 
 [deps]
+ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
+LazyBandedMatrices = "d7e5e226-e90b-4449-9968-0f923699bf6f"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MatrixFactorizations = "a3b82374-2e81-5b9e-98ce-41277c0e4c87"
 
 
 [compat]
-BandedMatrices = "0.13"
+ArrayLayouts = "0.1"
+BandedMatrices = "0.14"
 BlockArrays = "0.10"
-BlockBandedMatrices = "0.5.1"
+BlockBandedMatrices = "0.6"
 FillArrays = "0.8"
 InfiniteArrays = "0.4"
-LazyArrays = "0.13"
+LazyArrays = "0.14.4"
+LazyBandedMatrices = "0.0.1"
 MatrixFactorizations = "0.2"
 julia = "1.2"
 

src/InfiniteLinearAlgebra.jl

@@ -1,20 +1,22 @@
 module InfiniteLinearAlgebra
-using BlockArrays, BlockBandedMatrices, BandedMatrices, LazyArrays, FillArrays, InfiniteArrays, MatrixFactorizations, LinearAlgebra
+using BlockArrays, BlockBandedMatrices, BandedMatrices, LazyArrays, LazyBandedMatrices, 
+        FillArrays, InfiniteArrays, MatrixFactorizations, LinearAlgebra
 
 import Base: +, -, *, /, \, ^, OneTo, getindex, promote_op, _unsafe_getindex, print_matrix_row, size, axes,
             AbstractMatrix, AbstractArray, Matrix, Array, Vector, AbstractVector, Slice,
             show, getproperty
 import Base.Broadcast: BroadcastStyle, Broadcasted
 
-import InfiniteArrays: OneToInf, InfUnitRange, Infinity, InfStepRange, AbstractInfUnitRange
-import FillArrays: AbstractFill, getindex_value
+import ArrayLayouts: colsupport, rowsupport, triangularlayout, MatLdivVec, triangulardata, TriangularLayout, sublayout
 import BandedMatrices: BandedMatrix, _BandedMatrix, AbstractBandedMatrix, bandeddata, bandwidths, BandedColumns, bandedcolumns,
                         _default_banded_broadcast
+import FillArrays: AbstractFill, getindex_value      
+import InfiniteArrays: OneToInf, InfUnitRange, Infinity, InfStepRange, AbstractInfUnitRange                  
 import LinearAlgebra: lmul!,  ldiv!, matprod, qr, AbstractTriangular, AbstractQ, adjoint, transpose
 import LazyArrays: applybroadcaststyle, CachedArray, CachedMatrix, CachedVector, DenseColumnMajor, FillLayout, ApplyMatrix, check_mul_axes, ApplyStyle, LazyArrayApplyStyle, LazyArrayStyle,
                     CachedMatrix, CachedArray, resizedata!, MemoryLayout, mulapplystyle, LmulStyle, RmulStyle,
-                    colsupport, rowsupport, triangularlayout, factorize, subarraylayout, sub_materialize, LazyLayout, LazyArrayStyle,
-                    @lazymul, applylayout, ApplyLayout, TriangularLayout, PaddedLayout, materialize!, MatLdivVec, triangulardata
+                    factorize, sub_materialize, LazyLayout, LazyArrayStyle,
+                    @lazymul, applylayout, ApplyLayout, PaddedLayout, materialize!
 import MatrixFactorizations: ql, ql!, QLPackedQ, getL, getR, reflector!, reflectorApply!, QL, QR, QRPackedQ
 
 import BlockArrays: BlockSizes, cumulsizes, _find_block, AbstractBlockVecOrMat, sizes_from_blocks
@@ -25,11 +27,12 @@ import BlockBandedMatrices: _BlockSkylineMatrix, _BandedMatrix, AbstractBlockSiz
         BlockSkylineSizes, BlockSkylineMatrix, BlockBandedMatrix, _BlockBandedMatrix, BlockTridiagonal
 
 
+LazyArrays.@lazymul BandedMatrix{<:Any,<:Any,<:OneToInf}
 
 
 # BroadcastStyle(::Type{<:BandedMatrix{<:Any,<:Any,<:OneToInf}}) = LazyArrayStyle{2}()
 
-^(A::BandedMatrix{T,<:Any,<:OneToInf}, p::Integer) where T =
+function ^(A::BandedMatrix{T,<:Any,<:OneToInf}, p::Integer) where T
     if p < 0 
         inv(A)^(-p)
     elseif p == 0
@@ -39,7 +42,7 @@ import BlockBandedMatrices: _BlockSkylineMatrix, _BandedMatrix, AbstractBlockSiz
     else
         A*A^(p-1)
     end
-    
+end
 
 if VERSION < v"1.2-"
     import Base: has_offset_axes

src/banded/hessenbergq.jl

@@ -93,7 +93,7 @@ check_mul_axes(A::AbstractHessenbergQ, B, C...) =
 @lazymul AbstractHessenbergQ
 
 # ambiguities
-for Arr in (:AbstractBandedMatrix, :StridedVector, :StridedMatrix)
+for Arr in (:AbstractBandedMatrix, :StridedVector, :StridedMatrix, :(BandedMatrix{<:Any,<:Any,<:OneToInf}))
     @eval begin
         *(A::AbstractHessenbergQ, B::$Arr) = apply(*, A, B)
         *(A::$Arr, B::AbstractHessenbergQ) = apply(*, A, B)

src/banded/infbanded.jl

@@ -290,11 +290,11 @@ MemoryLayout(::Type{<:ConstRowMatrix}) = ConstRows()
 MemoryLayout(::Type{<:PertConstRowMatrix}) = PertConstRows()
 bandedcolumns(::ConstRows) = BandedToeplitzLayout()
 bandedcolumns(::PertConstRows) = PertToeplitzLayout()
-subarraylayout(::ConstRows, inds...) = subarraylayout(ApplyLayout{typeof(*)}(), inds...)
-subarraylayout(::PertConstRows, inds...) = subarraylayout(ApplyLayout{typeof(hcat)}(), inds...)
+sublayout(::ConstRows, inds...) = sublayout(ApplyLayout{typeof(*)}(), inds...)
+sublayout(::PertConstRows, inds...) = sublayout(ApplyLayout{typeof(hcat)}(), inds...)
 for Typ in (:ConstRows, :PertConstRows)
     @eval begin
-        subarraylayout(::$Typ, ::Type{<:Tuple{Any,AbstractInfUnitRange{Int}}}) = $Typ() # no way to lose const rows
+        sublayout(::$Typ, ::Type{<:Tuple{Any,AbstractInfUnitRange{Int}}}) = $Typ() # no way to lose const rows
         applybroadcaststyle(::Type{<:AbstractMatrix}, ::$Typ) = LazyArrayStyle{2}()
         applylayout(::Type, ::$Typ, _...) = LazyLayout()
     end
@@ -312,10 +312,10 @@ _BandedMatrix(::PertToeplitzLayout, A::AbstractMatrix) =
 
 # for Lay in (:BandedToeplitzLayout, :PertToeplitzLayout)
 #     @eval begin    
-#         subarraylayout(::$Lay, ::Type{<:Tuple{AbstractInfUnitRange{Int},AbstractInfUnitRange{Int}}}) = $Lay()
-#         subarraylayout(::$Lay, ::Type{<:Tuple{Slice,AbstractInfUnitRange{Int}}}) = $Lay()
-#         subarraylayout(::$Lay, ::Type{<:Tuple{AbstractInfUnitRange{Int},Slice}}) = $Lay()
-#         subarraylayout(::$Lay, ::Type{<:Tuple{Slice,Slice}}) = $Lay()
+#         sublayout(::$Lay, ::Type{<:Tuple{AbstractInfUnitRange{Int},AbstractInfUnitRange{Int}}}) = $Lay()
+#         sublayout(::$Lay, ::Type{<:Tuple{Slice,AbstractInfUnitRange{Int}}}) = $Lay()
+#         sublayout(::$Lay, ::Type{<:Tuple{AbstractInfUnitRange{Int},Slice}}) = $Lay()
+#         sublayout(::$Lay, ::Type{<:Tuple{Slice,Slice}}) = $Lay()
 
 #         sub_materialize(::$Lay, V) = BandedMatrix(V)    
 #     end

test/runtests.jl

@@ -2,12 +2,12 @@ using InfiniteLinearAlgebra, BlockBandedMatrices, BlockArrays, BandedMatrices, I
 import InfiniteLinearAlgebra: qltail, toeptail, tailiterate , tailiterate!, tail_de, ql_X!,
                     InfToeplitz, PertToeplitz, TriToeplitz, InfBandedMatrix, 
                     rightasymptotics, QLHessenberg, ConstRows, PertConstRows, BandedToeplitzLayout, PertToeplitzLayout
-
+import Base: BroadcastStyle
 import BlockArrays: _BlockArray                    
 import BlockBandedMatrices: isblockbanded, _BlockBandedMatrix
 import MatrixFactorizations: QLPackedQ
-import BandedMatrices: bandeddata, _BandedMatrix
-import LazyArrays: colsupport, ApplyStyle, MemoryLayout, ApplyLayout
+import BandedMatrices: bandeddata, _BandedMatrix, BandedStyle
+import LazyArrays: colsupport, ApplyStyle, MemoryLayout, ApplyLayout, LazyArrayStyle
 
 @testset "∞-Toeplitz and Pert-Toeplitz" begin
     A = BandedMatrix(1 => Fill(2im,∞), 2 => Fill(-1,∞), 3 => Fill(2,∞), -2 => Fill(-4,∞), -3 => Fill(-2im,∞))
@@ -106,6 +106,10 @@ end
         @test Eye(∞) * A isa BandedMatrix
         @test A * Eye(∞) isa BandedMatrix
         b = 1:∞
+        @test BroadcastStyle(typeof(b)) isa LazyArrayStyle{1}
+        @test BroadcastStyle(typeof(A)) isa BandedStyle
+        @test BroadcastStyle(LazyArrayStyle{1}(), BandedStyle()) isa LazyArrayStyle{2}
+        @test BroadcastStyle(LazyArrayStyle{2}(), BandedStyle()) isa LazyArrayStyle{2}
         @test bandwidths(b .* A) == (0,1)
 
         @test colsupport(b.*A, 1) == 1:1

test/test_infqr.jl

@@ -1,5 +1,6 @@
-using InfiniteLinearAlgebra, LinearAlgebra, BandedMatrices, InfiniteArrays, MatrixFactorizations, LazyArrays, FillArrays, SpecialFunctions
+using InfiniteLinearAlgebra, LinearAlgebra, BandedMatrices, InfiniteArrays, MatrixFactorizations, LazyArrays, FillArrays, SpecialFunctions, Test
 import LazyArrays: colsupport, rowsupport, MemoryLayout, DenseColumnMajor, TriangularLayout, resizedata!
+import LazyBandedMatrices: BroadcastBandedLayout
 import BandedMatrices: _BandedMatrix, _banded_qr!, BandedColumns
 import InfiniteLinearAlgebra: partialqr!, AdaptiveQRData, AdaptiveLayout
 
@@ -109,6 +110,8 @@ import InfiniteLinearAlgebra: partialqr!, AdaptiveQRData, AdaptiveLayout
         B = BandedMatrix(-2 => Ones(∞), -1 => Vcat(1, Zeros(∞)), 0 => Vcat([1,2,3],Zeros(∞)).+3, 1 => Vcat(1, Zeros(∞)), 2 => Ones(∞))
 
         AB = BroadcastArray(+,A,B)
+        @test MemoryLayout(typeof(AB)) isa BroadcastBandedLayout{typeof(+)}
+
         C = cache(AB);
         resizedata!(C,103,100); resizedata!(C,203,200);
         @test C[103,104] ≈ 1.0