Move BandedMatrices+BlockArrays to BlockArray extension

.github/workflows/docs.yml

@@ -24,7 +24,7 @@ jobs:
       - uses: julia-actions/setup-julia@v2
         with:
           version: '1.10'
-      - uses: julia-actions/cache@v1
+      - uses: julia-actions/cache@v2
       - name: Install dependencies
         run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
       - name: Build and deploy

Project.toml

@@ -1,6 +1,6 @@
 name = "BlockBandedMatrices"
 uuid = "ffab5731-97b5-5995-9138-79e8c1846df0"
-version = "0.12.11"
+version = "0.13"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -20,12 +20,12 @@ BlockBandedMatricesSparseArraysExt = "SparseArrays"
 [compat]
 Aqua = "0.8"
 ArrayLayouts = "1"
-BandedMatrices = "0.17.2, 1"
-BlockArrays = "0.16.34"
+BandedMatrices = "1"
+BlockArrays = "1"
 Documenter = "1"
 FillArrays = "1"
 LinearAlgebra = "1.6"
-MatrixFactorizations = "1, 2"
+MatrixFactorizations = "1, 2, 3"
 Random = "1.6"
 SparseArrays = "1.6"
 Test = "1.6"

docs/Project.toml

@@ -6,6 +6,6 @@ FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
-BlockArrays = "0.16"
+BlockArrays = "1"
 Documenter = "1"
 FillArrays = "1"

docs/src/index.md

@@ -50,7 +50,7 @@ the strided matrix interface, but we can also use BLAS and LAPACK to, for exampl
 upper-triangularize a block column all at once.
 
 
-A `BandedBlockBandedMatrix` stores the entries as a `PseudoBlockMatrix`,
+A `BandedBlockBandedMatrix` stores the entries as a `BlockedMatrix`,
 with the number of row blocks equal to `A.l + A.u + 1`, and the row
 block sizes are all `A.μ + A.λ + 1`. The column block sizes of the storage is
 the same as the the column block sizes of the `BandedBlockBandedMatrix`. This
@@ -69,7 +69,7 @@ of row and column blocks, then `A` has zero structure
    ⋅    ⋅   │ a_53  ⋅
    ⋅    ⋅   │ a_63 a_64 ]
 ```
-and is stored in memory via `A.data` as a `PseudoBlockMatrix`, which has block sizes
+and is stored in memory via `A.data` as a `BlockedMatrix`, which has block sizes
 2 x 2, containing entries:
 ```julia
 [a_11 a_22 │ a_33 a_44

examples/blockarray_backend.jl

@@ -4,7 +4,7 @@ using CuArrays
 using CuArrays.CUBLAS: libcublas_handle, cublasSetStream_v2, CuDefaultStream
 using CUDAnative.CUDAdrv: CuStream
 using GPUArrays
-using BlockArrays: _BlockArray, PseudoBlockArray, BlockArray, BlockMatrix, BlockVector,
+using BlockArrays: _BlockArray, BlockedArray, BlockArray, BlockMatrix, BlockVector,
                   nblocks, Block, cumulsizes, AbstractBlockVector
 using BlockBandedMatrices: BandedBlockBandedMatrix, _BandedBlockBandedMatrix,
                            blockbandwidths, subblockbandwidths, blockbandwidth,
@@ -22,13 +22,13 @@ import LinearAlgebra
 # BlockArrays
 adapt(T::Type{<:AbstractArray}, b::BlockArray) =
     _BlockArray(T.(b.blocks), b.block_sizes)
-adapt(T::Type{<:AbstractArray}, b::PseudoBlockArray) =
-    PseudoBlockArray(T(b.blocks), b.block_sizes)
-adapt(T::Type{<:PseudoBlockArray}, b::BlockArray) = T(b.blocks, b.block_sizes)
-adapt(T::Type{<:BlockArray}, b::PseudoBlockArray) = T(b.blocks, b.block_sizes)
+adapt(T::Type{<:AbstractArray}, b::BlockedArray) =
+    BlockedArray(T(b.blocks), b.block_sizes)
+adapt(T::Type{<:BlockedArray}, b::BlockArray) = T(b.blocks, b.block_sizes)
+adapt(T::Type{<:BlockArray}, b::BlockedArray) = T(b.blocks, b.block_sizes)
 # CuArrays and BlockArrays
 if @isdefined CuArray
-  adapt(T::Type{<:CuArray}, b::PseudoBlockArray) = adapt(T, BlockArray(b))
+  adapt(T::Type{<:CuArray}, b::BlockedArray) = adapt(T, BlockArray(b))
 end
 ###############
 
@@ -138,22 +138,22 @@ function testme()
       end
     end
 
-    @testset "PseudoBlockArray Adapters" begin
-      bmat = PseudoBlockArray{Float64}(undef, [1, 1], [2, 2])
+    @testset "BlockedArray Adapters" begin
+      bmat = BlockedArray{Float64}(undef, [1, 1], [2, 2])
       @test eltype(adapt(JLArray, bmat)) === Float64
-      @test adapt(JLArray, bmat) isa PseudoBlockArray
+      @test adapt(JLArray, bmat) isa BlockedArray
       if @isdefined CuArray
-        @test !(adapt(CuArray, bmat) isa PseudoBlockArray)
+        @test !(adapt(CuArray, bmat) isa BlockedArray)
         @test adapt(CuArray, bmat) isa BlockArray{T, 2, CuArray{T, 2}} where T
         @test cu(bmat) isa BlockArray{T, 2, CuArray{T, 2}} where T
         @test eltype(cu(bmat)) === Float32
       end
     end
 
-    @testset "PseudoBlockArray Adapters" begin
+    @testset "BlockedArray Adapters" begin
       bmat = BandedBlockBandedMatrix{Float64}(undef, ([1, 1], [2, 2]), (1, 2), (1, 1))
       @test adapt(JLArray, bmat) isa BandedBlockBandedMatrix
-      @test adapt(JLArray, bmat).data isa PseudoBlockArray{T, 2, JLArray{T, 2}} where T
+      @test adapt(JLArray, bmat).data isa BlockedArray{T, 2, JLArray{T, 2}} where T
       @test eltype(adapt(JLArray, bmat)) === Float64
       if @isdefined CuArray
         @test adapt(CuArray, bmat).data isa BlockArray{T, 2, CuArray{T, 2}} where T
@@ -172,7 +172,7 @@ function testme()
        Ablock = adapt(BlockArray, A)
        cblock = BlockArray(Array{Float64, 1}(undef, size(A, 1)), n)
        cblock .= rand.()
-       x = PseudoBlockArray(Array{Float64, 1}(undef, size(A, 2)), m)
+       x = BlockedArray(Array{Float64, 1}(undef, size(A, 2)), m)
        x .= rand.()
        xblock = adapt(BlockArray, x)
 
@@ -192,7 +192,7 @@ using Statistics
 function benchmarks()
   suite = BenchmarkGroup()
   # suite["viabm"] = BenchmarkGroup()
-  suite["pseudo"] = BenchmarkGroup()
+  suite["blocked"] = BenchmarkGroup()
   suite["block"] = BenchmarkGroup()
   if @isdefined CuArrays
     suite["gpu"] = BenchmarkGroup()
@@ -205,12 +205,12 @@ function benchmarks()
     A = BandedBlockBandedMatrix{Float64}(
              undef, (repeat([n], N), repeat([m], M)), (l, u), (λ, μ))
     A.data .= rand.()
-    c = PseudoBlockArray(Array{Float64, 1}(undef, size(A, 1)), repeat([n], N))
+    c = BlockedArray(Array{Float64, 1}(undef, size(A, 1)), repeat([n], N))
     c .= rand.()
-    x = PseudoBlockArray(Array{Float64, 1}(undef, size(A, 2)), repeat([m], M))
+    x = BlockedArray(Array{Float64, 1}(undef, size(A, 2)), repeat([m], M))
     x .= rand.()
 
-    suite["pseudo"]["N=$N n=$n"] = @benchmarkable begin
+    suite["blocked"]["N=$N n=$n"] = @benchmarkable begin
       $c .= Mul($A, $x)
     end
     suite["block"]["N=$N n=$n"] = @benchmarkable begin
@@ -234,6 +234,6 @@ function benchmarks()
 end
 
 block_ratio(result, name; method=median) =
-    ratio(method(result["block"][name]), method(result["pseudo"][name]))
+    ratio(method(result["block"][name]), method(result["blocked"][name]))
 viabm_ratio(result, name; method=median) =
     ratio(method(result["viabm"][name]), method(result["block"][name]))

examples/shared_array_backend.jl

@@ -1,4 +1,4 @@
-using BlockArrays: _BlockArray, PseudoBlockArray, BlockArray, BlockMatrix, BlockVector,
+using BlockArrays: _BlockArray, BlockedArray, BlockArray, BlockMatrix, BlockVector,
                   nblocks, Block, cumulsizes, AbstractBlockVector
 using BlockBandedMatrices: BandedBlockBandedMatrix, _BandedBlockBandedMatrix,
                            blockbandwidths, subblockbandwidths, blockbandwidth,
@@ -15,12 +15,12 @@ import Adapt: adapt
 
 adapt(T::Type, b::BandedBlockBandedMatrix) =
     _BandedBlockBandedMatrix(adapt(T, b.data), b.block_sizes)
-adapt(T::Type{<:AbstractArray}, b::PseudoBlockArray) =
-    PseudoBlockArray(T(b.blocks), b.block_sizes)
+adapt(T::Type{<:AbstractArray}, b::BlockedArray) =
+    BlockedArray(T(b.blocks), b.block_sizes)
 
 
 const SharedBandedBlockBandedMatrix =
-    BandedBlockBandedMatrix{T, PseudoBlockArray{T, 2, SharedArray{T, 2}}} where T
+    BandedBlockBandedMatrix{T, BlockedArray{T, 2, SharedArray{T, 2}}} where T
 
 function SharedBandedBlockBandedMatrix{T}(::UndefInitializer,
                                           bs::BandedBlockBandedSizes;
@@ -155,15 +155,15 @@ function testme()
        n, m = rand(max(l, u, λ, μ):20, N), rand(max(l, u, λ, μ):20, M)
        A = BandedBlockBandedMatrix{Float64}(undef, (n, m), (l, u), (λ, μ))
        A.data .= rand.()
-       x = PseudoBlockArray(Array{Float64, 1}(undef, size(A, 2)), m)
+       x = BlockedArray(Array{Float64, 1}(undef, size(A, 2)), m)
        x .= rand.()
 
        Ashared = adapt(SharedArray, A)
        @test Ashared.data.blocks isa SharedArray
        @test Ashared isa SharedBandedBlockBandedMatrix
        @test length(procs(Ashared)) == max(1, length(procs()) - 1)
        cshared = adapt(SharedArray,
-                      PseudoBlockArray(Array{Float64, 1}(undef, size(A, 1)), n))
+                      BlockedArray(Array{Float64, 1}(undef, size(A, 1)), n))
        @test cshared.blocks isa SharedArray
        cshared .= rand.()
        xshared = adapt(SharedArray, x)

examples/sharedarrays.jl

@@ -7,7 +7,7 @@ pids = addprocs(4)
 function shared_BandedBlockBandedMatrix(::UndefInitializer, bs::BlockSizes, (l, u), (λ, μ); pids=Int[])
     bs = BandedBlockBandedSizes(bs, l, u, λ, μ)
     data = SharedMatrix{Float64}((l+u+1)*(λ+μ+1), size(A,2); pids=pids)
-    _BandedBlockBandedMatrix(PseudoBlockArray(data, bs.data_block_sizes), bs)
+    _BandedBlockBandedMatrix(BlockedArray(data, bs.data_block_sizes), bs)
 end
 
 shared_BandedBlockBandedMatrix(::UndefInitializer, (N,M), (l, u), (λ, μ); pids=Int[]) =

src/BandedBlockBandedMatrix.jl

@@ -39,15 +39,14 @@
     end
 end
 
-const DefaultBandedBlockBandedMatrix{T} = BandedBlockBandedMatrix{T, PseudoBlockMatrix{T, Matrix{T}, NTuple{2,DefaultBlockAxis}}, DefaultBlockAxis}
+const DefaultBandedBlockBandedMatrix{T} = BandedBlockBandedMatrix{T, BlockedMatrix{T, Matrix{T}, NTuple{2,DefaultBlockAxis}}, DefaultBlockAxis}
 
 @inline _BandedBlockBandedMatrix(data::AbstractMatrix, axes::NTuple{2,AbstractUnitRange{Int}}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) =
-    _BandedBlockBandedMatrix(PseudoBlockArray(data,(blockedrange(Fill(sum(λμ)+1,sum(lu)+1)),axes[2])), axes[1], lu, λμ)
+    _BandedBlockBandedMatrix(BlockedArray(data,(blockedrange(Fill(sum(λμ)+1,sum(lu)+1)),axes[2])), axes[1], lu, λμ)
 
 @inline _BandedBlockBandedMatrix(data::AbstractMatrix,rblocksizes::AbstractVector{Int}, cblocksizes::AbstractVector{Int}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) =
     _BandedBlockBandedMatrix(data, (blockedrange(rblocksizes),blockedrange(cblocksizes)), lu, λμ)
 
-_blocklengths2blocklasts(b::Fill) = cumsum(b)
 _bbb_data_axes(caxes, lu, λμ) = (blockedrange(Fill(max(0,sum(λμ)+1),max(0,sum(lu)+1))),caxes)
 
 BandedBlockBandedMatrix{T,B,R}(::UndefInitializer, axes::NTuple{2,AbstractUnitRange{Int}}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where {T,B,R<:AbstractUnitRange{Int}} =
@@ -61,7 +60,7 @@
     BandedBlockBandedMatrix{T,B}(undef, (blockedrange(rblocksizes),blockedrange(cblocksizes)), lu, λμ)
 
 BandedBlockBandedMatrix{T}(::UndefInitializer, axes::NTuple{2,AbstractUnitRange{Int}}, lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T =
-    _BandedBlockBandedMatrix(PseudoBlockMatrix{T}(undef, _bbb_data_axes(axes[2],lu,λμ)), axes[1], lu, λμ)
+    _BandedBlockBandedMatrix(BlockedMatrix{T}(undef, _bbb_data_axes(axes[2],lu,λμ)), axes[1], lu, λμ)
 """
     BandedBlockBandedMatrix{T}(undef, rows, cols, (l, u), (λ, μ))
 
@@ -242,11 +241,11 @@
 similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::NTuple{2,AbstractUnitRange{Int}}) where T =
     BandedBlockBandedMatrix{T}(undef, axes, blockbandwidths(A), subblockbandwidths(A))
 
-@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{BlockedUnitRange,AbstractUnitRange{Int}}) where T =
+@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{AbstractBlockedUnitRange,AbstractUnitRange{Int}}) where T =
     BandedBlockBandedMatrix{T}(undef, axes, blockbandwidths(A), subblockbandwidths(A))
-@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{AbstractUnitRange{Int},BlockedUnitRange}) where T =
+@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{AbstractUnitRange{Int},AbstractBlockedUnitRange}) where T =
     BandedBlockBandedMatrix{T}(undef, axes, blockbandwidths(A), subblockbandwidths(A))
-@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{BlockedUnitRange,BlockedUnitRange}) where T =
+@inline similar(A::BandedBlockBandedMatrix, ::Type{T}, axes::Tuple{AbstractBlockedUnitRange,AbstractBlockedUnitRange}) where T =
     BandedBlockBandedMatrix{T}(undef, axes, blockbandwidths(A), subblockbandwidths(A))
 
 
@@ -289,7 +288,7 @@
 # default is to use whole block
 _subblockbandwidths(A::AbstractMatrix, ::NTuple{2,OneTo{Int}}) = bandwidths(A)
 function _subblockbandwidths(A::AbstractMatrix, _)
-    M,N = map(maximum, blocksizes(A))
+    M,N = map(maximum, blocklengths.(axes(A)))
     M-1,N-1
 end
 
@@ -401,7 +400,7 @@
     SubArray{T,2,<:BandedBlockBandedMatrix{T},<:Tuple{BlockSlice{R1},BlockSlice{R2}}}
 
 const SingleBlockInd = Union{BlockSlice1, BlockSlice{<:BlockIndexRange1}}
-const BlockRangeInd = Union{BlockSlices, BlockedUnitRange}
+const BlockRangeInd = Union{BlockSlices, AbstractBlockedUnitRange}
 
 sublayout(::BandedBlockBandedColumns{ML}, ::Type{II}) where {ML,II<:Tuple{SingleBlockInd,SingleBlockInd}} = bandedcolumns(sublayout(ML(), II))
 sublayout(::BandedBlockBandedColumns{ML}, ::Type{II}) where {ML,II<:Tuple{BlockRangeInd,BlockRangeInd}} = bandedblockbandedcolumns(sublayout(ML(), II))
@@ -410,7 +409,7 @@
 
 _blockaxes1(A::BlockSlice) = A.block
 _blockaxes1(A::Slice) = _blockaxes1(A.indices)
-_blockaxes1(A::BlockedUnitRange) = blockaxes(A,1)
+_blockaxes1(A::AbstractBlockedUnitRange) = blockaxes(A,1)
 blockbandshift(A, B) = BandedMatrices.bandshift(Int.(_blockaxes1(A)), Int.(_blockaxes1(B)))
 blockbandshift(S) = blockbandshift(parentindices(S)...)
 
@@ -427,13 +426,11 @@
 
 
 sub_materialize(::AbstractBandedBlockBandedLayout, V, _) = BandedBlockBandedMatrix(V)
-sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{<:BlockedUnitRange,<:BlockedUnitRange}) = BandedBlockBandedMatrix(V)
-sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{<:AbstractUnitRange,<:BlockedUnitRange}) = PseudoBlockArray(V)
-sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{<:BlockedUnitRange,<:AbstractUnitRange}) = PseudoBlockArray(V)
+sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{AbstractBlockedUnitRange,AbstractBlockedUnitRange}) = BandedBlockBandedMatrix(V)
+sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{AbstractUnitRange,AbstractBlockedUnitRange}) = BlockedArray(V)
+sub_materialize(::AbstractBandedBlockBandedLayout, V, ::Tuple{AbstractBlockedUnitRange,AbstractUnitRange}) = BlockedArray(V)
 
 
-sub_materialize(::AbstractBandedLayout, V, ::Tuple{<:BlockedUnitRange,<:BlockedUnitRange}) = BandedMatrix(V)
-
 
 isbanded(A::SubArray{<:Any,2,<:BandedBlockBandedMatrix}) = MemoryLayout(A) isa AbstractBandedLayout
 isbandedblockbanded(A::SubArray{<:Any,2,<:BandedBlockBandedMatrix}) = MemoryLayout(A) isa AbstractBandedBlockBandedLayout
@@ -442,7 +439,7 @@
 subblockbandwidths(V::SubArray) = subblockbandwidths(parent(V))
 
 
-_firstblock(B::BlockedUnitRange) = Int(first(blockaxes(B,1)))
+_firstblock(B::AbstractBlockedUnitRange) = Int(first(blockaxes(B,1)))
 _firstblock(B::Block{1}) = Int(B)
 _firstblock(B::BlockIndexRange) = _firstblock(B.block)
 _firstblock(B::BlockRange) = first(B.indices[1])

src/BlockBandedMatrices.jl

@@ -19,11 +19,12 @@ import Base: *, +, -, /, \, ==, @propagate_inbounds, OneTo, Slice, axes, checkbo
 
 import Base.Broadcast: AbstractArrayStyle, BroadcastStyle, Broadcasted, DefaultArrayStyle, broadcasted
 
-import BlockArrays: AbstractBlockLayout, Block, BlockIndexRange, BlockLayout, BlockSlice, BlockSlice1, BlockSlices,
-                    BlockStyle, BlockedUnitRange, DefaultBlockAxis, _blockkron, _blocklengths2blocklasts, block,
+import BlockArrays: AbstractBlockLayout, AbstractBlockedUnitRange, Block, BlockIndexRange, BlockLayout, BlockBidiagonal, BlockDiagonal,
+                    BlockSlice, BlockSlice1, BlockSlices, BlockStyle, BlockTridiagonal, BlockedUnitRange, DefaultBlockAxis,
+                    _blockkron, _blocklengths2blocklasts, block,
                     blockcheckbounds, blockcolstart, blockcolstop, blockcolsupport, blockindex, blockisequal,
-                    blockrowstart, blockrowstop, blockrowsupport, blocks, blocksize, hasmatchingblocks,
-                    sizes_from_blocks
+                    blockrowstart, blockrowstop, blockrowsupport, blocks, blocksize, checksquareblocks,
+                    hasmatchingblocks, sizes_from_blocks
 
 import FillArrays: Fill, Ones, Zeros
 
@@ -34,7 +35,6 @@ import LinearAlgebra.BLAS: BlasComplex, BlasFloat, BlasReal
 
 import MatrixFactorizations: AdjQLPackedQLayout, QR, QRPackedQ, _ql, ql, ql!
 
-
 export BandedBlockBandedMatrix, BlockBandedMatrix, BlockSkylineMatrix, blockbandwidth, blockbandwidths,
         subblockbandwidth, subblockbandwidths, Ones, Zeros, Fill, Block, BlockTridiagonal, BlockBidiagonal, isblockbanded
 

src/BlockSkylineMatrix.jl

@@ -52,7 +52,7 @@ struct BlockSkylineSizes{BS<:NTuple{2,AbstractUnitRange{Int}}, LL<:AbstractVecto
     u::UU
 end
 
-const BlockBandedSizes = BlockSkylineSizes{NTuple{2,BlockedUnitRange{Vector{Int}}}, Fill{Int,1,Tuple{OneTo{Int}}}, Fill{Int,1,Tuple{OneTo{Int}}},
+const BlockBandedSizes = BlockSkylineSizes{NTuple{2,BlockedOneTo{Int,Vector{Int}}}, Fill{Int,1,Tuple{OneTo{Int}}}, Fill{Int,1,Tuple{OneTo{Int}}},
                                             BandedMatrix{Int,Matrix{Int},OneTo{Int}}, Vector{Int}}
 
 
@@ -121,7 +121,7 @@ number of sub and super-block-bands in each column.
 julia> using LinearAlgebra, FillArrays
 
 julia> BlockSkylineMatrix(I, [2,2,2,4], [1,2,3], ([2,0,1],[0,1,1]))
-4×3-blocked 10×6 BlockSkylineMatrix{Bool, Vector{Bool}, BlockBandedMatrices.BlockSkylineSizes{Tuple{BlockArrays.BlockedUnitRange{Vector{Int64}}, BlockArrays.BlockedUnitRange{Vector{Int64}}}, Vector{Int64}, Vector{Int64}, BandedMatrices.BandedMatrix{Int64, Matrix{Int64}, Base.OneTo{Int64}}, Vector{Int64}}}:
+4×3-blocked 10×6 BlockSkylineMatrix{Bool, Vector{Bool}, BlockBandedMatrices.BlockSkylineSizes{Tuple{BlockArrays.BlockedOneTo{Int64, Vector{Int64}}, BlockArrays.BlockedOneTo{Int64, Vector{Int64}}}, Vector{Int64}, Vector{Int64}, BandedMatrices.BandedMatrix{Int64, Matrix{Int64}, Base.OneTo{Int64}}, Vector{Int64}}}:
  1  │  0  0  │  ⋅  ⋅  ⋅
  0  │  1  0  │  ⋅  ⋅  ⋅
  ───┼────────┼─────────
@@ -137,7 +137,7 @@ julia> BlockSkylineMatrix(I, [2,2,2,4], [1,2,3], ([2,0,1],[0,1,1]))
  ⋅  │  ⋅  ⋅  │  0  0  0
 
 julia> BlockSkylineMatrix(Ones(9,6), [2,3,4], [1,2,3], ([2,0,0],[0,1,1]))
-3×3-blocked 9×6 BlockSkylineMatrix{Float64, Vector{Float64}, BlockBandedMatrices.BlockSkylineSizes{Tuple{BlockArrays.BlockedUnitRange{Vector{Int64}}, BlockArrays.BlockedUnitRange{Vector{Int64}}}, Vector{Int64}, Vector{Int64}, BandedMatrices.BandedMatrix{Int64, Matrix{Int64}, Base.OneTo{Int64}}, Vector{Int64}}}:
+3×3-blocked 9×6 BlockSkylineMatrix{Float64, Vector{Float64}, BlockBandedMatrices.BlockSkylineSizes{Tuple{BlockArrays.BlockedOneTo{Int64, Vector{Int64}}, BlockArrays.BlockedOneTo{Int64, Vector{Int64}}}, Vector{Int64}, Vector{Int64}, BandedMatrices.BandedMatrix{Int64, Matrix{Int64}, Base.OneTo{Int64}}, Vector{Int64}}}:
  1.0  │  1.0  1.0  │   ⋅    ⋅    ⋅
  1.0  │  1.0  1.0  │   ⋅    ⋅    ⋅
  ─────┼────────────┼───────────────