move out blockarrays

Author: dlfivefifty

Project.toml

@@ -26,7 +26,7 @@ FillArrays = "1.0"
 InfiniteArrays = "0.15"
 InfiniteRandomArrays = "0.2"
 Infinities = "0.1"
-LazyArrays = "2.0"
+LazyArrays = "2.2.5"
 LazyBandedMatrices = "0.10"
 LinearAlgebra = "1"
 MatrixFactorizations = "3.0"

src/InfiniteLinearAlgebra.jl

@@ -14,7 +14,7 @@ import Base.Broadcast: BroadcastStyle, Broadcasted, broadcasted
 
 import ArrayLayouts: AbstractBandedLayout, AbstractQLayout, AdjQRPackedQLayout, CNoPivot, DenseColumnMajor, FillLayout,
                      MatLdivVec, MatLmulMat, MatLmulVec, MemoryLayout, QRPackedQLayout, RangeCumsum, TriangularLayout,
-                     TridiagonalLayout, __qr, _bidiag_forwardsub!, _factorize, _qr, check_mul_axes, colsupport,
+                     TridiagonalLayout, __qr, _factorize, _qr, check_mul_axes, colsupport,
                      diagonaldata, ldiv!, lmul!, mul, mulreduce, reflector!, reflectorApply!,
                      rowsupport, sub_materialize, subdiagonaldata, sublayout, supdiagonaldata, transposelayout,
                      triangulardata, triangularlayout, zero!, materialize!
@@ -24,7 +24,7 @@ import BandedMatrices: BandedColumns, BandedMatrix, BandedMatrix, _BandedMatrix,
                        banded_similar, bandedcolumns, bandeddata, bandwidths
 
 import BlockArrays: AbstractBlockLayout, BlockLayout, BlockSlice, BlockSlice1, BlockedOneTo,
-                    blockcolsupport, sizes_from_blocks, OneToCumsum, AbstractBlockedUnitRange
+                    blockcolsupport, sizes_from_blocks, AbstractBlockedUnitRange
 
 import BlockBandedMatrices: AbstractBlockBandedLayout, BlockBandedMatrix, BlockSkylineMatrix,
                             BlockSkylineSizes, BlockTridiagonal, _BlockBandedMatrix, _BlockSkylineMatrix,

src/blockbanded/blockbanded.jl

@@ -1,92 +1,9 @@
-const OneToInfCumsum = RangeCumsum{Int,OneToInf{Int}}
-
-BlockArrays.sortedunion(::AbstractVector{<:PosInfinity}, ::AbstractVector{<:PosInfinity}) = [∞]
-function BlockArrays.sortedunion(::AbstractVector{<:PosInfinity}, b)
-    @assert isinf(length(b))
-    b
-end
-
-function BlockArrays.sortedunion(b, ::AbstractVector{<:PosInfinity})
-    @assert isinf(length(b))
-    b
-end
-BlockArrays.sortedunion(a::OneToInfCumsum, ::OneToInfCumsum) = a
 
 BlockBandedMatrices.blockbanded_colstop(A, x::InfiniteCardinal{0}) = x
 BlockBandedMatrices.blockbanded_rowstop(A, x::InfiniteCardinal{0}) = x
 
-BlockArrays.blocklasts(a::InfRanges) = Fill(length(a),1)
-
-BlockArrays.findblock(::BlockedOneTo, ::RealInfinity) = Block(ℵ₀)
-
-function BlockArrays.sortedunion(a::Vcat{Int,1,<:Tuple{Union{Int,AbstractVector{Int}},<:AbstractRange}},
-                                 b::Vcat{Int,1,<:Tuple{Union{Int,AbstractVector{Int}},<:AbstractRange}})
-    @assert a == b # TODO: generailse? Not sure how to do so in a type stable fashion
-    a
-end
-
-sizes_from_blocks(A::AbstractVector, ::Tuple{OneToInf{Int}}) = (map(length,A),)
-length(::BlockedOneTo{Int,<:InfRanges}) = ℵ₀
-
-const OneToInfBlocks = BlockedOneTo{Int,OneToInfCumsum}
-const OneToBlocks = BlockedOneTo{Int,OneToCumsum}
-
-axes(a::OneToInfBlocks) = (a,)
-axes(a::OneToBlocks) = (a,)
-
-LazyBandedMatrices.unitblocks(a::OneToInf) = blockedrange(Ones{Int}(length(a)))
-
-BlockArrays.dimlength(start, ::Infinity) = ℵ₀
-
-function copy(bc::Broadcasted{<:BroadcastStyle,<:Any,typeof(*),<:Tuple{Ones{T,1,Tuple{OneToInfBlocks}},AbstractArray{V,N}}}) where {N,T,V}
-    a,b = bc.args
-    @assert bc.axes == axes(b)
-    convert(AbstractArray{promote_type(T,V),N}, b)
-end
-
-function copy(bc::Broadcasted{<:BroadcastStyle,<:Any,typeof(*),<:Tuple{AbstractArray{T,N},Ones{V,1,Tuple{OneToInfBlocks}}}}) where {N,T,V}
-    a,b = bc.args
-    @assert bc.axes == axes(a)
-    convert(AbstractArray{promote_type(T,V),N}, a)
-end
-
-_block_interlace_axes(::Int, ax::Tuple{BlockedOneTo{Int,OneToInf{Int}}}...) = (blockedrange(Fill(length(ax), ∞)),)
-
-_block_interlace_axes(nbc::Int, ax::NTuple{2,BlockedOneTo{Int,OneToInf{Int}}}...) =
-    (blockedrange(Fill(length(ax) ÷ nbc, ∞)),blockedrange(Fill(mod1(length(ax),nbc), ∞)))
 
 
 include("infblocktridiagonal.jl")
 
 
-#######
-# block broadcasted
-######
-
-
-BroadcastStyle(::Type{<:SubArray{T,N,Arr,<:NTuple{N,BlockSlice{BlockRange{1,Tuple{II}}}},false}}) where {T,N,Arr<:BlockArray,II<:InfRanges} =
-    LazyArrayStyle{N}()
-
-# TODO: generalise following
-BroadcastStyle(::Type{<:BlockArray{T,N,<:AbstractArray{<:AbstractArray{T,N},N},<:NTuple{N,BlockedOneTo{Int,<:InfRanges}}}}) where {T,N} = LazyArrayStyle{N}()
-# BroadcastStyle(::Type{<:BlockedArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:InfRanges}}}}) where {T,N} = LazyArrayStyle{N}()
-BroadcastStyle(::Type{<:BlockArray{T,N,<:AbstractArray{<:AbstractArray{T,N},N},<:NTuple{N,BlockedOneTo{Int,<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
-# BroadcastStyle(::Type{<:BlockedArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedOneTo{Int,<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
-
-
-###
-# KronTrav
-###
-
-_krontrav_axes(A::OneToInf{Int}, B::OneToInf{Int}) = blockedrange(oneto(length(A)))
-
-
-struct InfKronTravBandedBlockBandedLayout <: AbstractLazyBandedBlockBandedLayout end
-MemoryLayout(::Type{<:KronTrav{<:Any,2,<:Any,NTuple{2,BlockedOneTo{Int,OneToInfCumsum}}}}) = InfKronTravBandedBlockBandedLayout()
-
-sublayout(::InfKronTravBandedBlockBandedLayout, ::Type{<:NTuple{2,BlockSlice1}}) = BroadcastBandedLayout{typeof(*)}()
-sublayout(::InfKronTravBandedBlockBandedLayout, ::Type{<:NTuple{2,BlockSlice{BlockRange{1,Tuple{OneTo{Int}}}}}}) = KronTravBandedBlockBandedLayout()
-
-copy(M::Mul{InfKronTravBandedBlockBandedLayout, InfKronTravBandedBlockBandedLayout}) = KronTrav((krontravargs(M.A) .* krontravargs(M.B))...)
-
-_broadcast_sub_arguments(::InfKronTravBandedBlockBandedLayout, M, V) = _broadcast_sub_arguments(KronTravBandedBlockBandedLayout(), M, V)

src/blockbanded/infblocktridiagonal.jl

@@ -1,42 +1,4 @@
-const BlockTriPertToeplitz{T} = BlockMatrix{T,Tridiagonal{Matrix{T},Vcat{Matrix{T},1,Tuple{Vector{Matrix{T}},Fill{Matrix{T},1,Tuple{OneToInf{Int}}}}}},
-                                        NTuple{2,BlockedOneTo{Int,Vcat{Int,1,Tuple{Vector{Int},InfStepRange{Int,Int}}}}}}
 
-const BlockTridiagonalToeplitzLayout = BlockLayout{TridiagonalToeplitzLayout,DenseColumnMajor}
-
-function BlockTridiagonal(adjA::Adjoint{T,BlockTriPertToeplitz{T}}) where T
-    A = parent(adjA)
-    BlockTridiagonal(Matrix.(adjoint.(A.blocks.du)),
-                     Matrix.(adjoint.(A.blocks.d)),
-                     Matrix.(adjoint.(A.blocks.dl)))
-end
-
-for op in (:-, :+)
-    @eval begin
-        function $op(A::BlockTriPertToeplitz{T}, λ::UniformScaling) where T
-            TV = promote_type(T,eltype(λ))
-            BlockTridiagonal(Vcat(convert.(AbstractVector{Matrix{TV}}, A.blocks.dl.args)...),
-                             Vcat(convert.(AbstractVector{Matrix{TV}}, broadcast($op, A.blocks.d, Ref(λ)).args)...),
-                             Vcat(convert.(AbstractVector{Matrix{TV}}, A.blocks.du.args)...))
-        end
-        function $op(λ::UniformScaling, A::BlockTriPertToeplitz{V}) where V
-            TV = promote_type(eltype(λ),V)
-            BlockTridiagonal(Vcat(convert.(AbstractVector{Matrix{TV}}, broadcast($op, A.blocks.dl.args))...),
-                             Vcat(convert.(AbstractVector{Matrix{TV}}, broadcast($op, Ref(λ), A.blocks.d).args)...),
-                             Vcat(convert.(AbstractVector{Matrix{TV}}, broadcast($op, A.blocks.du.args))...))
-        end
-        $op(adjA::Adjoint{T,BlockTriPertToeplitz{T}}, λ::UniformScaling) where T = $op(BlockTridiagonal(adjA), λ)
-        $op(λ::UniformScaling, adjA::Adjoint{T,BlockTriPertToeplitz{T}}) where T = $op(λ, BlockTridiagonal(adjA))
-    end
-end
-
-sizes_from_blocks(A::Diagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.diag, 1), size.(A.diag,2)
-sizes_from_blocks(A::Tridiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.d, 1), size.(A.d,2)
-sizes_from_blocks(A::LazyBandedMatrices.Tridiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.d, 1), size.(A.d,2)
-sizes_from_blocks(A::Bidiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.dv, 1), size.(A.dv,2)
-sizes_from_blocks(A::LazyBandedMatrices.Bidiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.dv, 1), size.(A.dv,2)
-
-axes_print_matrix_row(_, io, X, A, i, ::AbstractVector{<:PosInfinity}, sep) = nothing
-axes_print_matrix_row(::NTuple{2,AbstractBlockedUnitRange}, io, X, A, i, ::AbstractVector{<:PosInfinity}, sep) = nothing
 
 
 function BlockSkylineSizes(A::BlockTriPertToeplitz, (l,u)::NTuple{2,Int})