Skip to content

Commit

Permalink
Release 0.13 (#206)
Browse files Browse the repository at this point in the history 
* 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>
  • Loading branch information
@dlfivefifty @jishnub @dependabot
3 people authored May 18, 2024
1 parent 80aa721 commit 95fb340
Show file tree
Hide file tree
Showing 20 changed files with 105 additions and 255 deletions.
8 changes: 4 additions & 4 deletions Project.toml
View file
Original file line number Diff line number Diff line change
@@ -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"
Expand All @@ -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"
Expand Down
3 changes: 3 additions & 0 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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
Expand Down
2 changes: 1 addition & 1 deletion docs/Project.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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"
4 changes: 2 additions & 2 deletions docs/src/index.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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
Expand Down
36 changes: 18 additions & 18 deletions examples/blockarray_backend.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand All @@ -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
###############

Expand Down Expand Up @@ -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
Expand All @@ -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)

Expand All @@ -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()
Expand All @@ -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
Expand All @@ -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]))
12 changes: 6 additions & 6 deletions examples/shared_array_backend.jl
View file
Original file line number Diff line number Diff line change
@@ -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,
Expand All @@ -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;
Expand Down Expand Up @@ -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)
Expand Down
2 changes: 1 addition & 1 deletion examples/sharedarrays.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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[]) =
Expand Down
29 changes: 13 additions & 16 deletions src/BandedBlockBandedMatrix.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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}} =
Expand All @@ -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), (λ, μ))
Expand Down Expand Up @@ -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))


Expand Down Expand Up @@ -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

Expand Down Expand Up @@ -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))
Expand All @@ -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)...)

Expand All @@ -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
Expand All @@ -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])
Expand Down
12 changes: 6 additions & 6 deletions src/BlockBandedMatrices.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand All @@ -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}
Expand Down
Loading

2 comments on commit 95fb340

@dlfivefifty
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@JuliaRegistrator register

@JuliaRegistrator
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Registration pull request created: JuliaRegistries/General/107127

Tip: Release Notes

Did you know you can add release notes too? Just add markdown formatted text underneath the comment after the text
"Release notes:" and it will be added to the registry PR, and if TagBot is installed it will also be added to the
release that TagBot creates. i.e.

@JuliaRegistrator register

Release notes:

## Breaking changes

- blah

To add them here just re-invoke and the PR will be updated.

Tagging

After the above pull request is merged, it is recommended that a tag is created on this repository for the registered package version.

This will be done automatically if the Julia TagBot GitHub Action is installed, or can be done manually through the github interface, or via:

git tag -a v0.13.0 -m "<description of version>" 95fb34051fdbe9d6fe79259895b753345044aa79
git push origin v0.13.0

Please sign in to comment.