Release 0.13 (#206)

* Don't export names not owned by the package (#203)

* Move BandedMatrices+BlockArrays to BlockArray extension (#195)

* Move some banded matrix stuff to BlockArrays extension

* Update interfaceimpl.jl

* Move over more code

* tests pass

* Update Project.toml

* v0.13

* Update BlockBandedMatrices.jl

* Update BlockBandedMatrices.jl

* updates

* Bump julia-actions/cache from 1 to 2 (#204)

Bumps [julia-actions/cache](https://github.com/julia-actions/cache) from 1 to 2.
- [Release notes](https://github.com/julia-actions/cache/releases)
- [Commits](julia-actions/cache@v1...v2)

---
updated-dependencies:
- dependency-name: julia-actions/cache
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* PseudoBlockMatrix -> BlockedMatrix

* Update BlockSkylineMatrix.jl

* Update BandedBlockBandedMatrix.jl

* Move out banded code

---------

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: Jishnu Bhattacharya <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Author: 3 people

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"

README.md

@@ -22,6 +22,7 @@ storing the entries in the non-zero bands.
 A `BlockBandedMatrix` is a subtype of `BlockMatrix` of [BlockArrays.jl](https://github.com/JuliaArrays/BlockArrays.jl)
 whose layout of non-zero blocks is banded. We can construct a `BlockBandedMatrix` as follows:
 ```julia
+using FillArrays, LinearAlgebra
 l,u = 2,1          # block bandwidths
 N = M = 4          # number of row/column blocks
 cols = rows = 1:N  # block sizes
@@ -35,10 +36,12 @@ A `BandedBlockBandedMatrix` has the added structure that the blocks themselves a
 banded, and conform to the banded matrix interface of [BandedMatrices.jl](https://github.com/JuliaLinearAlgebra/BandedMatrices.jl).
 We can construct a `BandedBlockBandedMatrix` as follows:
 ```julia
+using FillArrays, LinearAlgebra
 l,u = 2,1          # block bandwidths
 λ,μ = 1,2          # sub-block bandwidths: the bandwidths of each block
 N = M = 4          # number of row/column blocks
 cols = rows = 1:N  # block sizes
+
 BandedBlockBandedMatrix(Zeros(sum(rows),sum(cols)), rows,cols, (l,u), (λ,μ)) # creates a banded-block-banded matrix of zeros
 BandedBlockBandedMatrix(Ones(sum(rows),sum(cols)), rows,cols, (l,u), (λ,μ))  # creates a banded-block-banded matrix with ones in the non-zero entries
 BandedBlockBandedMatrix(I, rows,cols, (l,u), (λ,μ))                          # creates a banded-block-banded identity matrix

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 @@ struct BandedBlockBandedMatrix{T, BLOCKS, RAXIS<:AbstractUnitRange{Int}} <: Abst
     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}(::UndefInitializer, rblocksizes::AbstractVector{Int
     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 @@ convert(::Type{AbstractMatrix{T}}, B::BandedBlockBandedMatrix{T}) where T = B
 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 @@ subblockbandwidths(A::BandedBlockBandedMatrix) = (A.λ, A.μ)
 # 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 @@ const SubBandedBlockBandedMatrix{T,R1,R2} =
     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 @@ sublayout(::BandedBlockBandedColumns{ML}, ::Type{II}) where {ML,II<:Tuple{BlockR
 
 _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 @@ sublayout(::AbstractBandedBlockBandedLayout, ::Type{<:Tuple{BlockRangeInd,Single
 
 
 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 @@ isbandedblockbanded(A::SubArray{<:Any,2,<:BandedBlockBandedMatrix}) = MemoryLayo
 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,9 +35,8 @@ 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
+        subblockbandwidth, subblockbandwidths, BlockTridiagonal, BlockBidiagonal, isblockbanded
 
 
 const Block1 = Block{1,Int}