Start update for Julia v0.7-alpha

Author: dlfivefifty

src/AbstractBlockBandedMatrix.jl

@@ -6,21 +6,21 @@ abstract type AbstractBlockBandedLayout <: MemoryLayout end
 
 
 
-doc"""
+"""
     blockbandwidths(A)
 
 Returns a tuple containing the upper and lower blockbandwidth of `A`.
 """
 blockbandwidths(A::AbstractMatrix) = blockbandwidth(A,1),blockbandwidth(A,2)
 
-doc"""
+"""
     blockbandwidth(A,i)
 
 Returns the lower blockbandwidth (`i==1`) or the upper blockbandwidth (`i==2`).
 """
 blockbandwidth(A::AbstractMatrix, k::Integer) = k==1 ? nblocks(A,1)-1 : nblocks(A,2)-1
 
-doc"""
+"""
     bandrange(A)
 
 Returns the range `-blockbandwidth(A,1):blockbandwidth(A,2)`.
@@ -48,7 +48,7 @@ end
 @inline blockrowlength(A::AbstractVecOrMat, i) = max(Int(blockrowstop(A, i)) - Int(blockrowstart(A, i)) + 1, 0)
 
 
-doc"""
+"""
     isblockbanded(A)
 
 returns true if a matrix implements the block banded interface.

src/BandedBlockBandedMatrix.jl

@@ -35,6 +35,8 @@ end
 convert(::Type{BlockBandedSizes}, B::BandedBlockBandedSizes) =
     BlockBandedSizes(B.block_sizes, B.l, B.u)
 
+BlockBandedSizes(B::BandedBlockBandedSizes) = convert(BlockBandedSizes, B)
+
 function check_data_sizes(data::AbstractBlockMatrix, B::BandedBlockBandedSizes)
     bs = data.block_sizes
     c_rows, c_cols = bs.cumul_sizes
@@ -105,7 +107,7 @@ BandedBlockBandedMatrix{T}(::UndefInitializer, dims::NTuple{2, AbstractVector{In
 
 function convert(::Type{BandedBlockBandedMatrix{T}}, B::BandedMatrix) where T
     if isdiag(B)
-        _BandedBlockBandedMatrix(copy(B.data), (ones(Int,size(B,1)),ones(Int,size(B,2))), (0,0), (0,0))
+        _BandedBlockBandedMatrix(copy(B.data), (fill(1,size(B,1)),fill(1,size(B,2))), (0,0), (0,0))
     else
         _BandedBlockBandedMatrix(copy(B.data), [size(B,1)], [size(B,2)], (0,0), (B.l,B.u))
     end
@@ -131,14 +133,14 @@ function BandedBlockBandedMatrix{T}(E::Eye, dims::NTuple{2,AbstractVector{Int}},
         throw(DimensionMismatch())
     end
     ret = BandedBlockBandedMatrix(Zeros{T}(E), dims, lu, λμ)
-    ret[diagind(ret)] = one(T)
+    ret[diagind(ret)] .= one(T)
     ret
 end
 
 function BandedBlockBandedMatrix{T}(A::UniformScaling, dims::NTuple{2, AbstractVector{Int}},
                                     lu::NTuple{2,Int}, λμ::NTuple{2,Int}) where T
     ret = BandedBlockBandedMatrix(Zeros{T}(sum.(dims)), dims, lu, λμ)
-    ret[diagind(ret)] = convert(T, A.λ)
+    ret[diagind(ret)] .= convert(T, A.λ)
     ret
 end
 
@@ -277,14 +279,14 @@ function Base.fill!(A::BandedBlockBandedMatrix, x)
     A
 end
 
-function Base.scale!(A::BandedBlockBandedMatrix, x::Number)
-    scale!(A.data, x)
+function rmul!(A::BandedBlockBandedMatrix, x::Number)
+    rmul!(A.data, x)
     A
 end
 
 
-function Base.scale!(x::Number, A::BandedBlockBandedMatrix)
-    scale!(x, A.data)
+function lmul!(x::Number, A::BandedBlockBandedMatrix)
+    lmul!(x, A.data)
     A
 end
 
@@ -334,14 +336,14 @@ end
 #     end
 # end
 #
-# @generated function Base.copy!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
+# @generated function Base.copyto!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
 #     return quote
 #         block_sizes = block_array.block_sizes
 #
 #         @nloops $N i i->(1:nblocks(block_sizes, i)) begin
 #             block_index = @ntuple $N i
 #             indices = globalrange(block_sizes, block_index)
-#             copy!(getblock(block_array, block_index...), arr[indices...])
+#             copyto!(getblock(block_array, block_index...), arr[indices...])
 #         end
 #
 #         return block_array
@@ -386,7 +388,7 @@ const BandedBlockBandedBlock{T} = SubArray{T,2,BandedBlockBandedMatrix{T},Tuple{
 
 function inblockbands(V::BandedBlockBandedBlock)
     A = parent(V)
-    K_sl, J_sl = parentindexes(V)
+    K_sl, J_sl = parentindices(V)
     K, J = K_sl.block, J_sl.block
     -A.l ≤ Int(J-K) ≤ A.u
 end
@@ -400,14 +402,14 @@ end
 
 
 # gives the columns of parent(V).data that encode the block
-blocks(V::BandedBlockBandedBlock)::Tuple{Int,Int} = Int(first(parentindexes(V)).block),
-                                                    Int(last(parentindexes(V)).block)
+blocks(V::BandedBlockBandedBlock)::Tuple{Int,Int} = Int(first(parentindices(V)).block),
+                                                    Int(last(parentindices(V)).block)
 
 
 function dataview(V::BandedBlockBandedBlock)
     A = parent(V)
     u = A.u
-    K_sl, J_sl = parentindexes(V)
+    K_sl, J_sl = parentindices(V)
     K, J = K_sl.block, J_sl.block
     view(A.data, u + K - J + 1, J)
 end
@@ -457,6 +459,9 @@ end
 
 convert(::Type{BandedMatrix}, V::BandedBlockBandedBlock) = convert(BandedMatrix{eltype(V)}, V)
 
+BandedMatrix{T}(V::BandedBlockBandedBlock) where T = convert(BandedMatrix{T}, V)
+BandedMatrix(V::BandedBlockBandedBlock) = convert(BandedMatrix, V)
+
 
 
 

src/BlockBandedMatrices.jl

@@ -2,6 +2,7 @@ __precompile__()
 
 module BlockBandedMatrices
 using BlockArrays, BandedMatrices, FillArrays, Compat
+using Compat.LinearAlgebra
 
 import BlockArrays: BlockSizes, nblocks, blocksize, blockcheckbounds, global2blockindex,
                         Block, BlockSlice, getblock, unblock, setblock!, globalrange,
@@ -17,17 +18,26 @@ import BandedMatrices: isbanded, leadingdimension, bandwidth, banded_getindex,
                         _BandedMatrix, colstart, colstop, rowstart, rowstop
 
 import Base: getindex, setindex!, checkbounds, @propagate_inbounds, convert,
-                        isdiag, +, *, -, /, \, strides, zeros, eye, size,
-                        unsafe_convert, copy!, fill!, length, done, first, last, next,
-                        start, iteratorsize, eltype, getindex, to_indices, to_index,
+                        +, *, -, /, \, strides, zeros, size,
+                        unsafe_convert, fill!, length, done, first, last, next,
+                        start, eltype, getindex, to_indices, to_index,
                         reindex, _maybetail, tail, @_propagate_inbounds_meta
 
-import Base.LinAlg: A_ldiv_B!, A_mul_B!
-import Base.BLAS: BlasInt, BlasFloat, @blasfunc, libblas
-import Base.LAPACK: chktrans, chkdiag, liblapack, chklapackerror, checksquare, chkstride1,
+import Compat.LinearAlgebra: A_ldiv_B!, A_mul_B!, UniformScaling, isdiag
+import Compat.LinearAlgebra.BLAS: BlasInt, BlasFloat, @blasfunc, libblas
+import Compat.LinearAlgebra.LAPACK: chktrans, chkdiag, liblapack, chklapackerror, checksquare, chkstride1,
                     chkuplo
 
-import Compat: axes
+
+import Compat: axes, copyto!
+
+if VERSION < v"0.7-"
+    const rmul! = scale!
+    const lmul! = scale!
+    const parentindices = parentindexes
+else
+    import LinearAlgebra: rmul!, lmul!
+end
 
 export BandedBlockBandedMatrix, BlockBandedMatrix, blockbandwidth, blockbandwidths,
         subblockbandwidth, subblockbandwidths, Ones, Zeros, Fill, Block

src/BlockBandedMatrix.jl

@@ -27,7 +27,7 @@ end
 
 function bb_blockstrides(b_size, l, u)
     N, M = nblocks(b_size)
-    b_strides = Vector{Int}(M)
+    b_strides = Vector{Int}(undef, M)
     for J=1:M
         KR = max(1,J-u):min(J+l,N)
         if !isempty(KR)
@@ -136,13 +136,13 @@ function BlockBandedMatrix{T}(E::Eye, block_sizes::BlockBandedSizes) where T
         throw(DimensionMismatch("Size of input $(size(E)) must be consistent with $(sum.(dims))"))
     end
     ret = BlockBandedMatrix(Zeros{T}(size(E)), block_sizes)
-    ret[diagind(ret)] = one(T)
+    ret[diagind(ret)] .= one(T)
     ret
 end
 
 function BlockBandedMatrix{T}(A::UniformScaling, block_sizes::BlockBandedSizes) where T
     ret = BlockBandedMatrix(Zeros{T}(size(block_sizes)), block_sizes)
-    ret[diagind(ret)] = convert(T, A.λ)
+    ret[diagind(ret)] .= convert(T, A.λ)
     ret
 end
 
@@ -165,6 +165,8 @@ function convert(::Type{BlockBandedMatrix}, A::AbstractMatrix)
 end
 
 
+BlockBandedMatrix(A::AbstractMatrix) = convert(BlockBandedMatrix, A)
+
 ################################
 # BlockBandedMatrix Interface #
 ################################
@@ -272,14 +274,14 @@ end
 #     end
 # end
 #
-# @generated function Base.copy!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
+# @generated function Base.copyto!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
 #     return quote
 #         block_sizes = block_array.block_sizes
 #
 #         @nloops $N i i->(1:nblocks(block_sizes, i)) begin
 #             block_index = @ntuple $N i
 #             indices = globalrange(block_sizes, block_index)
-#             copy!(getblock(block_array, block_index...), arr[indices...])
+#             copyto!(getblock(block_array, block_index...), arr[indices...])
 #         end
 #
 #         return block_array
@@ -306,8 +308,8 @@ const BlockBandedBlock{T} = SubArray{T,2,BlockBandedMatrix{T},Tuple{BlockSlice1,
 
 
 # gives the columns of parent(V).data that encode the block
-blocks(V::BlockBandedBlock)::Tuple{Int,Int} = first(first(parentindexes(V)).block.n),
-                                                    first(last(parentindexes(V)).block.n)
+blocks(V::BlockBandedBlock)::Tuple{Int,Int} = first(first(parentindices(V)).block.n),
+                                                    first(last(parentindices(V)).block.n)
 
 ######################################
 # Matrix interface  for Blocks #