Move out Lazy arrays (#49)

dlfivefifty · web-flow · commit 1c3b9d453751 · 2019-11-08T21:37:08.000Z
* Update for ArrayLayouts

* Update test_triblockbanded.jl

* import mul
diff --git a/Project.toml b/Project.toml
@@ -1,27 +1,26 @@
 name = "BlockBandedMatrices"
 uuid = "ffab5731-97b5-5995-9138-79e8c1846df0"
-version = "0.5.3"
+version = "0.6"
 
 [deps]
 BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
-LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
+ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MatrixFactorizations = "a3b82374-2e81-5b9e-98ce-41277c0e4c87"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
-Profile = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
-BandedMatrices = "0.13"
+BandedMatrices = "0.14"
 BlockArrays = "0.10"
 FillArrays = "0.8"
-LazyArrays = "0.13"
+ArrayLayouts = "0.1"
 MatrixFactorizations = "0.2"
 julia = "1"
diff --git a/examples/blockarray_backend.jl b/examples/blockarray_backend.jl
@@ -12,7 +12,7 @@ using BlockBandedMatrices: BandedBlockBandedMatrix, _BandedBlockBandedMatrix,
 using LinearAlgebra: BLAS
 using BandedMatrices: _BandedMatrix
 using SharedArrays
-using LazyArrays
+using ArrayLayouts
 import Distributed
 
 import Adapt: adapt
@@ -117,7 +117,7 @@ function banded_mul!(c::BlockVector{T},
       B = _BandedMatrix(A.data.blocks[i - j + u + 1, j],
                         size(view(A, Block(i, j)), 1), 
                         λ, μ)
-      c[Block(i)] .+= Mul(B, x.blocks[j])
+        muladd!(one(T), B, x.blocks[j], one(T), c[Block(i)])
     end
 
     c
diff --git a/examples/cuarrays.jl b/examples/cuarrays.jl
@@ -1,4 +1,4 @@
-using BandedMatrices, BlockBandedMatrices, LazyArrays, BlockArrays, FillArrays, CuArrays, GPUArrays, LinearAlgebra
+using BandedMatrices, BlockBandedMatrices, ArrayLayouts, BlockArrays, FillArrays, CuArrays, GPUArrays, LinearAlgebra
 import BlockBandedMatrices: _BandedBlockBandedMatrix
 import BandedMatrices: _BandedMatrix
 
@@ -47,7 +47,7 @@ b = BlockVector{T, CuArray{T,1}}(undef, Fill(N,N))
 c = BlockVector{T, CuArray{T,1}}(Zeros{T}(N^2), Fill(N,N))
 
 
-function mul!(c, A::BandedBlockBandedMatrix{<:Any,<:BlockMatrix{<:Any,<:CuArray}}, b)
+function mul!(c, A::BandedBlockBandedMatrix{T,<:BlockMatrix{<:Any,<:CuArray}}, b) where T
     fill!(c, 0)
 
     l, u = blockbandwidths(A)
@@ -56,7 +56,7 @@ function mul!(c, A::BandedBlockBandedMatrix{<:Any,<:BlockMatrix{<:Any,<:CuArray}
 
     for J = 1:N, K = max(1,J-l):min(N,J+u)
         B = _BandedMatrix(A.data.blocks[K-J+u+1,J],N,λ,μ)
-        c.blocks[K] .= Mul(B, b.blocks[J]) .+ c.blocks[K]
+        muladd!(one(T), B, b.blocks[J], one(T), c.blocks[K])
     end
     c
 end
@@ -71,7 +71,7 @@ function mul!(c, A::BandedBlockBandedMatrix{<:Any,<:BlockMatrix{<:Any,<:CuArray}
 
     for J = 1:N, K = max(1,J-l):min(N,J+u)
         B = _BandedMatrix(A.data.blocks[K-J+u+1,J],N,λ,μ)
-        LazyArrays.materialize!(MulAdd(1f0, B, b.blocks[J], 1f0, c.blocks[K]))
+        ArrayLayouts.materialize!(MulAdd(1f0, B, b.blocks[J], 1f0, c.blocks[K]))
     end
     c
 end
@@ -87,15 +87,15 @@ function mul2!(c, A::BandedBlockBandedMatrix{<:Any,<:BlockMatrix{<:Any,<:CuArray
         for J = 1-b:M
             K = J + b
             B = _BandedMatrix(A.data.blocks[b+u+1,J],N,λ,μ)
-            LazyArrays.materialize!(MulAdd(1f0, B, x.blocks[J], 1f0, c.blocks[K]))
+            ArrayLayouts.materialize!(MulAdd(1f0, B, x.blocks[J], 1f0, c.blocks[K]))
         end
     end
 
     @inbounds for b = 1:l
         for J = 1:M-b
             K = J + b
             B = _BandedMatrix(A.data.blocks[b+u+1,J],N,λ,μ)
-            LazyArrays.materialize!(MulAdd(1f0, B, x.blocks[J], 1f0, c.blocks[K]))
+            ArrayLayouts.materialize!(MulAdd(1f0, B, x.blocks[J], 1f0, c.blocks[K]))
         end
     end
 
diff --git a/examples/finitedifference_2d.jl b/examples/finitedifference_2d.jl
@@ -3,7 +3,7 @@
 #
 ###########
 
-using BlockBandedMatrices, BandedMatrices, LazyArrays, FillArrays
+using BlockBandedMatrices, BandedMatrices, ArrayLayouts, FillArrays
 
 
 function finitedifference_2d(n)
diff --git a/examples/shared_array_backend.jl b/examples/shared_array_backend.jl
@@ -7,7 +7,7 @@ using LinearAlgebra: BLAS
 import LinearAlgebra
 using BandedMatrices: _BandedMatrix, BandedMatrix
 using SharedArrays
-using LazyArrays
+using ArrayLayouts
 using Distributed: procs, remotecall_wait
 import Distributed
 
diff --git a/examples/sharedarrays_setup.jl b/examples/sharedarrays_setup.jl
@@ -1,7 +1,7 @@
 using Pkg
 
 Pkg.activate(homedir() * "/Documents/Coding/gpublockbanded")
-using BandedMatrices, BlockBandedMatrices, SharedArrays, LazyArrays, BlockArrays, FillArrays
+using BandedMatrices, BlockBandedMatrices, SharedArrays, ArrayLayouts, BlockArrays, FillArrays
 import BlockBandedMatrices: _BandedBlockBandedMatrix, BandedBlockBandedSizes, BlockSizes, blockcolrange
 import BandedMatrices: AbstractBandedMatrix, bandwidths, BandedStyle
 import Base: getindex, size
diff --git a/src/BlockBandedMatrices.jl b/src/BlockBandedMatrices.jl
@@ -1,6 +1,6 @@
 
 module BlockBandedMatrices
-using BlockArrays, BandedMatrices, LazyArrays, FillArrays, SparseArrays, MatrixFactorizations
+using BlockArrays, BandedMatrices, ArrayLayouts, FillArrays, SparseArrays, MatrixFactorizations
 using LinearAlgebra
 
 import Base: getindex, setindex!, checkbounds, @propagate_inbounds, convert,
@@ -22,11 +22,11 @@ import LinearAlgebra.LAPACK: chktrans, chkdiag, liblapack, chklapackerror, check
 import MatrixFactorizations: ql, ql!, QLPackedQ
 import SparseArrays: sparse
 
-import LazyArrays: AbstractStridedLayout, ColumnMajor, @lazymul, MatMulMatAdd, MatMulVecAdd, BlasMatLmulVec,
+import ArrayLayouts: @lazymul, MatMulMatAdd, MatMulVecAdd, BlasMatLmulVec,
                     triangularlayout, UpperTriangularLayout, TriangularLayout, MatLdivVec,
-                    triangulardata, subarraylayout, @lazyldiv, @lazylmul,
+                    triangulardata, sublayout, @lazyldiv, @lazylmul,
                     AbstractColumnMajor, DenseColumnMajor, ColumnMajor,
-                    DiagonalLayout, apply!, materialize!, MulAdd, mulapplystyle, MulAddStyle
+                    DiagonalLayout, materialize!, MulAdd, mul
 
 import BlockArrays: BlockSizes, nblocks, blocksize, blockcheckbounds, global2blockindex,
                         Block, BlockSlice, getblock, unblock, setblock!, globalrange,
diff --git a/src/blockskylineqr.jl b/src/blockskylineqr.jl
@@ -107,7 +107,7 @@ for Typ in (:StridedVector, :StridedMatrix, :AbstractVector, :AbstractMatrix)
         M,N = nblocks(A.factors)
         MN = min(M,N)
         V = view(A.factors,Block.(1:MN), Block.(1:MN))
-        apply!(\, UpperTriangular(V), view(B,1:size(V,1),:))
+        materialize!(Ldiv(UpperTriangular(V), view(B,1:size(V,1),:)))
         B
     end
 end
@@ -116,12 +116,12 @@ end
 
 function ldiv!(A::QL{<:Any,<:BlockSkylineMatrix}, B::AbstractVector)
     lmul!(adjoint(A.Q), B)
-    apply!(\, LowerTriangular(A.factors), B)
+    materialize!(Ldiv(LowerTriangular(A.factors), B))
 end
 
 function ldiv!(A::QL{<:Any,<:BlockSkylineMatrix}, B::AbstractMatrix)
     lmul!(adjoint(A.Q), B)
-    apply!(\, LowerTriangular(A.factors), B)
+    materialize!(Ldiv(LowerTriangular(A.factors), B))
 end
 
 \(A::AbstractBlockBandedMatrix, b::AbstractVecOrMat) = qr(A)\b  # use QR because LU would be a _mess_ to implement
diff --git a/src/interfaceimpl.jl b/src/interfaceimpl.jl
@@ -20,24 +20,6 @@ BroadcastStyle(::Type{<:SubArray{<:Any,2,<:PseudoBlockMatrix{<:Any,<:Diagonal},
                                 NTuple{2,BlockSlice1}}}) = BandedStyle()
 
 
-isblockbanded(K::Kron{<:Any,2}) = isbanded(first(K.args))
-isbandedblockbanded(K::Kron{<:Any,2}) = all(isbanded, K.args)
-blockbandwidths(K::Kron{<:Any,2}) = bandwidths(first(K.args))
-subblockbandwidths(K::Kron{<:Any,2}) = bandwidths(last(K.args))
-function blocksizes(K::Kron{<:Any,2})
-    A,B = K.args
-    BlockSizes(Fill(size(B,1), size(A,1)), Fill(size(B,2), size(A,2)))
-end
-
-const SubKron{T,M1,M2,R1,R2} =
-    SubArray{T,2,<:Kron{T,2,Tuple{M1,M2}},Tuple{BlockSlice{R1},BlockSlice{R2}}}
-
-
-BroadcastStyle(::Type{<:SubKron{<:Any,<:Any,B,Block1,Block1}}) where B =
-    BroadcastStyle(B)
-
-@inline bandwidths(V::SubKron{<:Any,<:Any,<:Any,Block1,Block1}) =
-    subblockbandwidths(parent(V))
 
 
 const BlockDiagonal{T,VT<:Matrix{T}} = BlockMatrix{T,<:Diagonal{VT}}
diff --git a/src/linalg.jl b/src/linalg.jl
@@ -39,7 +39,7 @@ function materialize!(M::MatMulVecAdd{<:AbstractBlockBandedLayout,<:AbstractStri
 
     for J = Block.(1:nblocks(A,2))
         for K = blockcolrange(A,J)
-            view(y,K) .= α .* Mul(view(A,K,J), view(x,J)) .+ view(y,K)
+            muladd!(α, view(A,K,J), view(x,J), one(α), view(y,K))
         end
     end
     y_in
@@ -48,9 +48,8 @@ end
 function materialize!(M::MatMulMatAdd{<:AbstractBlockBandedLayout,<:AbstractBlockBandedLayout,<:AbstractBlockBandedLayout})
     α, A, X, β, Y = M.α, M.A, M.B, M.β, M.C
     _fill_lmul!(β, Y)
-    for J=Block(1):Block(nblocks(X,2)),
-            N=blockcolrange(X,J), K=blockcolrange(A,N)
-        view(Y,K,J) .= α .* Mul( view(A,K,N), view(X,N,J)) .+ view(Y,K,J)
+    for J=Block(1):Block(nblocks(X,2)), N=blockcolrange(X,J), K=blockcolrange(A,N)
+        muladd!(α, view(A,K,N), view(X,N,J), one(α), view(Y,K,J))
     end
     Y
 end
@@ -61,7 +60,7 @@ function materialize!(M::MatMulMatAdd{<:AbstractBlockBandedLayout,<:AbstractColu
     X = PseudoBlockArray(X_in, BlockSizes((cumulsizes(blocksizes(A),2),[1,size(X_in,2)+1])))
     Y = PseudoBlockArray(Y_in, BlockSizes((cumulsizes(blocksizes(A),1), [1,size(Y_in,2)+1])))
     for N=Block.(1:nblocks(X,1)), K=blockcolrange(A,N)
-        view(Y,K,Block(1)) .= α .* Mul( view(A,K,N), view(X,N,Block(1))) .+ view(Y,K,Block(1))
+        muladd!(α, view(A,K,N), view(X,N,Block(1)), one(α), view(Y,K,Block(1)))
     end
     Y_in
 end
@@ -72,7 +71,7 @@ function materialize!(M::MatMulMatAdd{<:AbstractColumnMajor,<:AbstractBlockBande
     A = PseudoBlockArray(A_in, BlockSizes(([1,size(A_in,1)+1],cumulsizes(blocksizes(X),1))))
     Y = PseudoBlockArray(Y_in, BlockSizes(([1,size(Y_in,1)+1],cumulsizes(blocksizes(X),2))))
     for J=Block(1):Block(nblocks(X,2)), N=blockcolrange(X,J)
-        view(Y,Block(1),J) .= α .* Mul( view(A,Block(1),N), view(X,N,J)) .+ view(Y,Block(1),J)
+        muladd!(α, view(A,Block(1),N), view(X,N,J), one(α), view(Y,Block(1),J))
     end
     Y_in
 end
@@ -84,14 +83,14 @@ end
 # * overrides
 #############
 
-*(A::BlockBandedMatrix, B::BlockBandedMatrix) = materialize(Mul(A,B))
-*(A::BlockBandedMatrix, B::BandedBlockBandedMatrix) = materialize(Mul(A,B))
-*(A::BandedBlockBandedMatrix, B::BlockBandedMatrix) = materialize(Mul(A,B))
-*(A::BandedBlockBandedMatrix, B::BandedBlockBandedMatrix) = materialize(Mul(A,B))
-*(A::Matrix, B::BlockBandedMatrix) = materialize(Mul(A,B))
-*(A::BlockBandedMatrix, B::Matrix) = materialize(Mul(A,B))
-*(A::BandedBlockBandedMatrix, B::Matrix) = materialize(Mul(A,B))
-*(A::Matrix, B::BandedBlockBandedMatrix) = materialize(Mul(A,B))
+*(A::BlockBandedMatrix, B::BlockBandedMatrix) = mul(A,B)
+*(A::BlockBandedMatrix, B::BandedBlockBandedMatrix) = mul(A,B)
+*(A::BandedBlockBandedMatrix, B::BlockBandedMatrix) = mul(A,B)
+*(A::BandedBlockBandedMatrix, B::BandedBlockBandedMatrix) = mul(A,B)
+*(A::Matrix, B::BlockBandedMatrix) = mul(A,B)
+*(A::BlockBandedMatrix, B::Matrix) = mul(A,B)
+*(A::BandedBlockBandedMatrix, B::Matrix) = mul(A,B)
+*(A::Matrix, B::BandedBlockBandedMatrix) = mul(A,B)
 
 
 function add_bandwidths(A::AbstractBlockBandedMatrix,B::AbstractBlockBandedMatrix)
@@ -165,9 +164,6 @@ end
 similar(M::MulAdd{<:DiagonalLayout,<:AbstractBlockBandedLayout}, ::Type{T}) where T = similar(M.B,T)
 similar(M::MulAdd{<:AbstractBlockBandedLayout,<:DiagonalLayout}, ::Type{T}) where T = similar(M.A,T)
 
-mulapplystyle(::DiagonalLayout, ::AbstractBlockBandedLayout) = MulAddStyle()
-mulapplystyle(::AbstractBlockBandedLayout, ::DiagonalLayout) = MulAddStyle()
-
 
 
 function blocksizes(V::SubBlockSkylineMatrix{<:Any,LL,UU,BlockRange1,BlockRange1}) where {LL,UU}
@@ -202,17 +198,17 @@ end
 ####
 
 
-subarraylayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockRange1}}}) = BlockBandedColumnMajor()
-subarraylayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{Block1}}}) = ColumnMajor()
-subarraylayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockIndexRange1}}}) = ColumnMajor()
-subarraylayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockIndexRange1}, BlockSlice{BlockIndexRange1}}}) = ColumnMajor()
+sublayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockRange1}}}) = BlockBandedColumnMajor()
+sublayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{Block1}}}) = ColumnMajor()
+sublayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockIndexRange1}}}) = ColumnMajor()
+sublayout(::BlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockIndexRange1}, BlockSlice{BlockIndexRange1}}}) = ColumnMajor()
 
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{Block1}, BlockSlice{Block1}}}) = BandedColumnMajor()
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockRange1}}}) = BandedBlockBandedColumnMajor()
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{Block1}, BlockSlice{BlockRange1}}}) = BandedBlockBandedColumnMajor()
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{Block1}}}) = BandedBlockBandedColumnMajor()
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockIndexRange1}}}) = BandedBlockBandedColumnMajor()
-subarraylayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockIndexRange1}, BlockSlice{BlockIndexRange1}}}) = BandedBlockBandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{Block1}, BlockSlice{Block1}}}) = BandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockRange1}}}) = BandedBlockBandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{Block1}, BlockSlice{BlockRange1}}}) = BandedBlockBandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{Block1}}}) = BandedBlockBandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockRange1}, BlockSlice{BlockIndexRange1}}}) = BandedBlockBandedColumnMajor()
+sublayout(::BandedBlockBandedColumnMajor, ::Type{Tuple{BlockSlice{BlockIndexRange1}, BlockSlice{BlockIndexRange1}}}) = BandedBlockBandedColumnMajor()
 
 isbanded(A::SubArray{<:Any,2,<:BandedBlockBandedMatrix}) = MemoryLayout(typeof(A)) == BandedColumnMajor()
 isbandedblockbanded(A::SubArray{<:Any,2,<:BandedBlockBandedMatrix}) = MemoryLayout(typeof(A)) == BandedBlockBandedColumnMajor()
diff --git a/src/triblockbanded.jl b/src/triblockbanded.jl
@@ -45,7 +45,7 @@ _triangular_matrix(::Val{'U'}, ::Val{'U'}, A) = UnitUpperTriangular(A)
 _triangular_matrix(::Val{'L'}, ::Val{'U'}, A) = UnitLowerTriangular(A)
 
 
-function _matchingblocks_triangular_mul!(::Val{'U'}, UNIT, A, dest)
+function _matchingblocks_triangular_mul!(::Val{'U'}, UNIT, A::AbstractMatrix{T}, dest) where T
     # impose block structure
     b = PseudoBlockArray(dest, BlockSizes((cumulsizes(blocksizes(A),1),)))
 
@@ -55,16 +55,16 @@ function _matchingblocks_triangular_mul!(::Val{'U'}, UNIT, A, dest)
     for K = 1:N
         b_2 = view(b, Block(K))
         Ũ = _triangular_matrix(Val('U'), UNIT, view(A, Block(K,K)))
-        b_2 .= Mul(Ũ, b_2)
+        materialize!(Lmul(Ũ, b_2))
         JR = Block(K+1):blockrowstop(A,K)
         if !isempty(JR)
-            b_2 .= applied(+, applied(*, view(A, Block(K), JR), view(b,JR)), b_2)
+            muladd!(one(T), view(A, Block(K), JR), view(b,JR), one(T), b_2)
         end
     end
     dest
 end
 
-function _matchingblocks_triangular_mul!(::Val{'L'}, UNIT, A, dest)
+function _matchingblocks_triangular_mul!(::Val{'L'}, UNIT, A::AbstractMatrix{T}, dest) where T
     # impose block structure
     b = PseudoBlockArray(dest, BlockSizes((cumulsizes(blocksizes(A),1),)))
 
@@ -74,10 +74,10 @@ function _matchingblocks_triangular_mul!(::Val{'L'}, UNIT, A, dest)
     for K = N:-1:1
         b_2 = view(b, Block(K))
         L̃ = _triangular_matrix(Val('L'), UNIT, view(A, Block(K,K)))
-        b_2 .= Mul(L̃, b_2)
+        materialize!(Lmul(L̃, b_2))
         JR = blockrowstart(A,K):Block(K-1)
         if !isempty(JR)
-            b_2 .= applied(+, applied(*, view(A, Block(K), JR), view(b,JR)), b_2)
+            muladd!(one(T), view(A, Block(K), JR), view(b,JR), one(T), b_2)
         end
     end
 
@@ -119,7 +119,7 @@ for UNIT in ('U', 'N')
             for K = N:-1:1
                 b_2 = view(b, Block(K))
                 Ũ = _triangular_matrix(Val('U'), Val($UNIT), view(A, Block(K,K)))
-                apply!(\, Ũ, b_2)
+                materialize!(Ldiv(Ũ, b_2))
 
                 if K ≥ 2
                     KR = blockcolstart(A, K):Block(K-1)
@@ -150,7 +150,7 @@ for UNIT in ('U', 'N')
             for K = 1:N
                 b_2 = view(b, Block(K))
                 L̃ = _triangular_matrix(Val('L'), Val($UNIT), view(A, Block(K,K)))
-                b_2 .= Ldiv(L̃, b_2)
+                materialize!(Ldiv(L̃, b_2))
 
                 if K < N
                     KR = Block(K+1):blockcolstop(A, K)
diff --git a/test/test_bandedblockbanded.jl b/test/test_bandedblockbanded.jl
@@ -1,4 +1,4 @@
-using BlockArrays, BandedMatrices, BlockBandedMatrices, FillArrays, SparseArrays, Test, LazyArrays , LinearAlgebra
+using BlockArrays, BandedMatrices, BlockBandedMatrices, FillArrays, SparseArrays, Test, ArrayLayouts , LinearAlgebra
 import BlockBandedMatrices: _BandedBlockBandedMatrix, blockcolrange, blockrowrange, colrange, rowrange, isbandedblockbanded, bandeddata
 
 @testset "BandedBlockBandedMatrix" begin
@@ -304,7 +304,7 @@ import BlockBandedMatrices: _BandedBlockBandedMatrix, blockcolrange, blockrowran
 
         x = randn(size(B,2))
         y = similar(x, size(B,1))
-        @test all((similar(y) .= Mul(B, x)) .=== (similar(y) .= Mul(V,x)))
+        @test all((similar(y) .= MulAdd(B, x)) .=== (similar(y) .= MulAdd(V,x)))
     end
 
     @testset "BLAS arithmetic" begin
diff --git a/test/test_blockbanded.jl b/test/test_blockbanded.jl
@@ -1,6 +1,5 @@
-using BlockArrays, BandedMatrices, BlockBandedMatrices, FillArrays, LazyArrays, LinearAlgebra, Test
+using BlockArrays, BandedMatrices, BlockBandedMatrices, FillArrays, ArrayLayouts, LinearAlgebra, Test
 import BlockBandedMatrices: MemoryLayout, ColumnMajor, BroadcastStyle, BlockBandedStyle
-import LazyArrays: Mul, MulAdd
 import Base.Broadcast: materialize!
 
 @testset "BlockBandedMatrix" begin
@@ -147,7 +146,7 @@ import Base.Broadcast: materialize!
         @test sum(A) == 20
         @test sum(B) == 20
         C = BlockBandedMatrix{Float64}(undef, ([2,2], [2,2,2]), (0,3))
-        @test all(copyto!(C, Mul(A,B)) .=== materialize!(MulAdd(1.0,A,B,0.0,similar(C))) .===
+        @test all(mul!(C,A,B) .=== materialize!(MulAdd(1.0,A,B,0.0,similar(C))) .===
                     A*B)
         AB = A*B
         @test AB isa BlockBandedMatrix
diff --git a/test/test_blockskyline.jl b/test/test_blockskyline.jl
diff --git a/test/test_broadcasting.jl b/test/test_broadcasting.jl
diff --git a/test/test_linalg.jl b/test/test_linalg.jl
diff --git a/test/test_misc.jl b/test/test_misc.jl
diff --git a/test/test_triblockbanded.jl b/test/test_triblockbanded.jl

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`#`
`4`	`4`	`###########`
`5`	`5`
`6`		`-using BlockBandedMatrices, BandedMatrices, LazyArrays, FillArrays`
	`6`	`+using BlockBandedMatrices, BandedMatrices, ArrayLayouts, FillArrays`
`7`	`7`
`8`	`8`
`9`	`9`	`function finitedifference_2d(n)`