Develop block array interface (#54)

*Triangular/Symmetric/Hermitian conform to

* A.block_sizes -> blocksizes(A)

* Bump REQUIRE

* getindex -> cumulsize/s

* *Triangular/Symmetric/Hermitian conform to block array interace

* clean up cumulsizes

* BlockSizes -> AbstractBlockSizes

* view(view(A, Block(2,3)), Block(1,1)) now works as expected

Author: dlfivefifty

.travis.yml

@@ -3,8 +3,8 @@ language: julia
 os:
   - linux
 julia:
-  - 0.6
   - 0.7
+  - 1.0
   - nightly
 matrix:
    allow_failures:

REQUIRE

@@ -1,2 +1 @@
-julia 0.6
-Compat 0.66
+julia 0.7

docs/make.jl

@@ -8,7 +8,7 @@ makedocs(
     format = :html,
     sitename = "BlockArrays.jl",
     doctest = false,
-    strict = VERSION.minor == 6 && sizeof(Int) == 8, # only strict mode on 0.6 and Int64
+    strict = VERSION.major == 1 && sizeof(Int) == 8, # only strict mode on 1.0 and Int64
     pages = Any[
         "Home" => "index.md",
         "Manual" => [

docs/src/lib/public.md

@@ -32,6 +32,7 @@ Block
 BlockIndex
 nblocks
 blocksize
+blocksizes
 getblock
 getblock!
 setblock!

docs/src/man/abstractblockarrayinterface.md

@@ -1,16 +1,23 @@
-# The AbstractBlockArray interface
+# The `AbstractBlockSizes` interface
 
-In order to follow the `AbstractBlockArray` the following methods should be implemented:
+In order to follow the `AbstractBlockSizes` the following methods should be implemented:
 
 
 | Methods to implement    | Brief description |
 | :---------------------- | :---------------- |
+| `cumulsizes(A)`      | A Tuple of abstract vectors storing the cumulative block sizes |
+| **Optional methods**    |       
 | `nblocks(A)`            | Tuple of number of blocks in each dimension |
 | `nblocks(A, i)`         | Number of blocks in dimension `i` |
-| `blocksize(A, i...)`    | Size of the block at block index `i...` |
+| `blocksize(A, i)`    | Size of the block at block index `i` |
+
+# The `AbstractBlockArray` interface
+
+| Methods to implement    | Brief description |
+| `blocksizes(A)`         | Return a subtype of `AbstractBlockSizes` |
+| **Optional methods**    |                        |
 | `getblock(A, i...)`     | `X[Block(i...)]`, blocked indexing  |
 | `setblock!(A, v, i...)` | `X[Block(i...)] = v`, blocked index assignment |
-| **Optional methods**    |                        |
 | `getblock!(x, A, i)`    | `X[i]`, blocked index assignment with in place storage in `x` |
 
 For a more thorough description of the methods see the public interface documentation.
@@ -36,4 +43,3 @@ ERROR: BlockBoundsError: attempt to access 2×2-blocked 4×5 BlockArrays.BlockAr
 ```
 
 * Happy users who know how to use your new block array :)
-

src/BlockArrays.jl

@@ -2,14 +2,11 @@ __precompile__()
 
 module BlockArrays
 using Base.Cartesian
-using Compat
-if VERSION ≥ v"0.7.0-DEV.3465"
-    using LinearAlgebra
-end
+using LinearAlgebra
 
 # AbstractBlockArray interface exports
 export AbstractBlockArray, AbstractBlockMatrix, AbstractBlockVector, AbstractBlockVecOrMat
-export Block, getblock, getblock!, setblock!, nblocks, blocksize, blockcheckbounds, BlockBoundsError, BlockIndex
+export Block, getblock, getblock!, setblock!, nblocks, blocksize, blocksizes, blockcheckbounds, BlockBoundsError, BlockIndex
 export BlockRange
 
 export BlockArray, BlockMatrix, BlockVector, BlockVecOrMat
@@ -24,21 +21,14 @@ import Base: @propagate_inbounds, Array, to_indices, to_index,
             broadcast, eltype, convert, broadcast,
             @_inline_meta, _maybetail, tail, @_propagate_inbounds_meta, reindex,
             RangeIndex, Int, Integer, Number,
-            +, -, min, max, *, isless, in
-
-import Compat: copyto!, axes
-
-if VERSION < v"0.7-"
-    import Base: colon, iteratorsize, indices1, start, next, done
-    const parentindices = parentindexes
-    const axes1 = indices1
-    const lmul! = Base.scale!
-    const rmul! = Base.scale!
-else
-    import Base: (:), IteratorSize, iterate, axes1
-    import Base.Broadcast: broadcasted, DefaultArrayStyle
-    import LinearAlgebra: lmul!, rmul!
-end
+            +, -, min, max, *, isless, in, copyto!, axes, @deprecate
+
+
+
+import Base: (:), IteratorSize, iterate, axes1
+import Base.Broadcast: broadcasted, DefaultArrayStyle
+import LinearAlgebra: lmul!, rmul!, AbstractTriangular
+
 
 include("abstractblockarray.jl")
 
@@ -49,8 +39,9 @@ include("pseudo_blockarray.jl")
 include("blockrange.jl")
 include("views.jl")
 include("blockindexrange.jl")
-include("convert.jl")
 include("show.jl")
+include("blockarrayinterface.jl")
+
 include("deprecate.jl")
 
 end # module

src/abstractblockarray.jl

@@ -45,35 +45,12 @@ julia> nblocks(A, 3, 2)
 (4, 3)
 ```
 """
-nblocks(block_array::AbstractBlockArray, i::Int) = nblocks(block_array)[i]
-
-function nblocks(block_array::AbstractBlockArray, i::Vararg{Int, N}) where {N}
-    if N == 0
-        throw(error("nblocks(A) not implemented"))
-    end
-    b = nblocks(block_array)
-    return ntuple(k-> b[i[k]], Val(N))
-end
+nblocks(block_array::AbstractArray, i::Int) = nblocks(block_array)[i]
 
+nblocks(block_array::AbstractArray, i::Vararg{Int, N}) where {N} =
+    nblocks(blocksizes(block_array), i...)
 
-"""
-    blocksize(A, inds...)
-
-Returns a tuple containing the size of the block at block index `inds...`.
 
-```jldoctest
-julia> A = BlockArray(rand(5, 4, 6), [1, 4], [1, 2, 1], [1, 2, 2, 1]);
-
-julia> blocksize(A, 1, 3, 2)
-(1, 1, 2)
-
-julia> blocksize(A, 2, 1, 3)
-(4, 1, 2)
-```
-"""
-function blocksize(A::AbstractBlockArray{T,N}, ::Vararg{Int, N}) where {T,N}
-    throw(error("blocksize for ", typeof(A), " is not implemented"))
-end
 
 """
     Block(inds...)

src/blockarray.jl

@@ -189,12 +189,29 @@ end
     end
 end
 
+# Convert AbstractArrays that conform to block array interface
+convert(::Type{BlockArray{T,N,R}}, A::BlockArray{T,N,R}) where {T,N,R} = A
+convert(::Type{BlockArray{T,N}}, A::BlockArray{T,N}) where {T,N} = A
+convert(::Type{BlockArray{T}}, A::BlockArray{T}) where {T} = A
+convert(::Type{BlockArray}, A::BlockArray) = A
+
+BlockArray{T, N}(A::AbstractArray{T2, N}) where {T,T2,N} =
+    BlockArray(Array{T, N}(A), blocksizes(A))
+BlockArray{T1}(A::AbstractArray{T2, N}) where {T1,T2,N} = BlockArray{T1, N}(A)
+BlockArray(A::AbstractArray{T, N}) where {T,N} = BlockArray{T, N}(A)
+
+convert(::Type{BlockArray{T, N}}, A::AbstractArray{T2, N}) where {T,T2,N} =
+    BlockArray(convert(Array{T, N}, A), blocksizes(A))
+convert(::Type{BlockArray{T1}}, A::AbstractArray{T2, N}) where {T1,T2,N} =
+    convert(BlockArray{T1, N}, A)
+convert(::Type{BlockArray}, A::AbstractArray{T, N}) where {T,N} =
+    convert(BlockArray{T, N}, A)
+
+
 ################################
 # AbstractBlockArray Interface #
 ################################
-
-@inline nblocks(block_array::BlockArray) = nblocks(block_array.block_sizes)
-@inline blocksize(block_array::BlockArray{T,N}, i::Vararg{Int, N}) where {T,N} = blocksize(block_array.block_sizes, i)
+@inline blocksizes(block_array::BlockArray) = block_array.block_sizes
 
 @inline function getblock(block_arr::BlockArray{T,N}, block::Vararg{Int, N}) where {T,N}
     @boundscheck blockcheckbounds(block_arr, block...)
@@ -215,22 +232,18 @@ end
 ###########################
 
 @inline function Base.similar(block_array::BlockArray{T,N}, ::Type{T2}) where {T,N,T2}
-    _BlockArray(similar(block_array.blocks, Array{T2, N}), copy(block_array.block_sizes))
-end
-
-@inline function Base.size(arr::BlockArray{T,N}) where {T,N}
-    size(arr.block_sizes)
+    _BlockArray(similar(block_array.blocks, Array{T2, N}), copy(blocksizes(block_array)))
 end
 
 @inline function Base.getindex(block_arr::BlockArray{T, N}, i::Vararg{Int, N}) where {T,N}
     @boundscheck checkbounds(block_arr, i...)
-    @inbounds v = block_arr[global2blockindex(block_arr.block_sizes, i)]
+    @inbounds v = block_arr[global2blockindex(blocksizes(block_arr), i)]
     return v
 end
 
 @inline function Base.setindex!(block_arr::BlockArray{T, N}, v, i::Vararg{Int, N}) where {T,N}
     @boundscheck checkbounds(block_arr, i...)
-    @inbounds block_arr[global2blockindex(block_arr.block_sizes, i)] = v
+    @inbounds block_arr[global2blockindex(blocksizes(block_arr), i)] = v
     return block_arr
 end
 
@@ -240,8 +253,8 @@ end
 
 function _check_setblock!(block_arr::BlockArray{T, N}, v, block::NTuple{N, Int}) where {T,N}
     for i in 1:N
-        if size(v, i) != blocksize(block_arr.block_sizes, i, block[i])
-            throw(DimensionMismatch(string("tried to assign $(size(v)) array to ", blocksize(block_arr, block...), " block")))
+        if size(v, i) != blocksize(block_arr, i, block[i])
+            throw(DimensionMismatch(string("tried to assign $(size(v)) array to ", blocksize(block_arr, block), " block")))
         end
     end
 end
@@ -265,7 +278,7 @@ end
 @generated function Base.Array(block_array::BlockArray{T, N, R}) where {T,N,R}
     # TODO: This will fail for empty block array
     return quote
-        block_sizes = block_array.block_sizes
+        block_sizes = blocksizes(block_array)
         arr = similar(block_array.blocks[1], size(block_array)...)
         @nloops $N i i->(1:nblocks(block_sizes, i)) begin
             block_index = @ntuple $N i
@@ -279,7 +292,7 @@ end
 
 @generated function copyto!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
     return quote
-        block_sizes = block_array.block_sizes
+        block_sizes = blocksizes(block_array)
 
         @nloops $N i i->(1:nblocks(block_sizes, i)) begin
             block_index = @ntuple $N i

src/blockarrayinterface.jl

@@ -0,0 +1,13 @@
+
+blocksizes(A::AbstractTriangular) = blocksizes(parent(A))
+
+
+blocksizes(A::Symmetric) = blocksizes(parent(A))
+blocksizes(A::Hermitian) = blocksizes(parent(A))
+
+Base.print_matrix_row(io::IO,
+        X::Union{AbstractTriangular{<:Any,<:AbstractBlockMatrix},
+                 Symmetric{<:Any,<:AbstractBlockMatrix},
+                 Hermitian{<:Any,<:AbstractBlockMatrix}}, A::Vector,
+        i::Integer, cols::AbstractVector, sep::AbstractString) =
+        _blockarray_print_matrix_row(io, X, A, i, cols, sep)

src/blockindexrange.jl

@@ -20,41 +20,25 @@ getindex(B::Block{N}, inds::Vararg{AbstractUnitRange{Int},N}) where N = BlockInd
 eltype(R::BlockIndexRange) = eltype(typeof(R))
 eltype(::Type{BlockIndexRange{N}}) where {N} = BlockIndex{N}
 eltype(::Type{BlockIndexRange{N,R}}) where {N,R} = BlockIndex{N}
-if VERSION < v"0.7.0-DEV.4043"
-    iteratorsize(::Type{<:BlockIndexRange}) = Base.HasShape()
-else
-    IteratorSize(::Type{<:BlockIndexRange}) = Base.HasShape{1}()
-end
+IteratorSize(::Type{<:BlockIndexRange}) = Base.HasShape{1}()
+
 
 first(iter::BlockIndexRange) = BlockIndex(iter.block.n, map(first, iter.indices))
 last(iter::BlockIndexRange)  = BlockIndex(iter.block.n, map(last, iter.indices))
 
-if VERSION < v"0.7-"
-    @inline function start(iter::BlockIndexRange)
-        iterfirst, iterlast = first(iter), last(iter)
-        if any(map(>, iterfirst.α, iterlast.α))
-            return BlockIndex(iterlast.I, iterlast.α .+ 1)
-        end
-        iterfirst
-    end
-    @inline function next(iter::BlockIndexRange, state)
-        state, BlockIndex(state.I, inc(state.α, first(iter).α, last(iter).α))
-    end
-    @inline done(iter::BlockIndexRange, state) = state.α[end] > last(iter.indices[end])
-else
-    @inline function iterate(iter::BlockIndexRange)
-        iterfirst, iterlast = first(iter), last(iter)
-        if any(map(>, iterfirst.α, iterlast.α))
-            return nothing
-        end
-        iterfirst, iterfirst
-    end
-    @inline function iterate(iter::BlockIndexRange, state)
-        nextstate = BlockIndex(state.I, inc(state.α, first(iter).α, last(iter).α))
-        nextstate.α[end] > last(iter.indices[end]) && return nothing
-        nextstate, nextstate
+@inline function iterate(iter::BlockIndexRange)
+    iterfirst, iterlast = first(iter), last(iter)
+    if any(map(>, iterfirst.α, iterlast.α))
+        return nothing
     end
+    iterfirst, iterfirst
+end
+@inline function iterate(iter::BlockIndexRange, state)
+    nextstate = BlockIndex(state.I, inc(state.α, first(iter).α, last(iter).α))
+    nextstate.α[end] > last(iter.indices[end]) && return nothing
+    nextstate, nextstate
 end
+
 size(iter::BlockIndexRange) = map(dimlength, first(iter).α, last(iter).α)
 length(iter::BlockIndexRange) = prod(size(iter))
 
@@ -65,22 +49,11 @@ Block(bs::BlockIndexRange) = bs.block
 ### Views
 Block(bs::BlockSlice{<:BlockIndexRange}) = Block(bs.block)
 
+function _unblock(cum_sizes, I::Tuple{BlockIndexRange{1,R}, Vararg{Any}}) where {R}
+    B = Block(first(I))
+    range = cum_sizes[Int(B)]-1 .+ first(I).indices[1]
 
-
-if VERSION < v"0.7-"
-    function _unblock(cum_sizes, I::Tuple{BlockIndexRange{1,R}, Vararg{Any}}) where {R}
-        B = Block(first(I))
-        range = cum_sizes[Int(B)]-1 + first(I).indices[1]
-
-        BlockSlice(I[1], range)
-    end
-else # only 0.7- and above support broadcasting with a Range returning a Range
-    function _unblock(cum_sizes, I::Tuple{BlockIndexRange{1,R}, Vararg{Any}}) where {R}
-        B = Block(first(I))
-        range = cum_sizes[Int(B)]-1 .+ first(I).indices[1]
-
-        BlockSlice(I[1], range)
-    end
+    BlockSlice(I[1], range)
 end
 
 
@@ -107,6 +80,8 @@ reindex(V, idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
                                     reindex(V, tail(idxs), tail(subidxs))...))
 
 
+
+
 # #################
 # # support for pointers
 # #################