update for new block arrays (#27)

* update for new block arrays

* updates

* Drop old Julia versions

* v0.3

Author: dlfivefifty

.travis.yml

@@ -4,9 +4,6 @@ os:
   - linux
   - osx
 julia:
-  - "1.0"
-  - "1.1"
-  - "1.2"
   - "1.3"  
   - nightly
 matrix:

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.2.3"
+version = "0.3"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -29,8 +29,8 @@ ToeplitzMatrices = "c751599d-da0a-543b-9d20-d0a503d91d24"
 [compat]
 AbstractFFTs = "0.4, 0.5"
 BandedMatrices = "0.14"
-BlockArrays = "0.10"
-BlockBandedMatrices = "0.6"
+BlockArrays = "0.11"
+BlockBandedMatrices = "0.7"
 Calculus = "0.5"
 DSP = "0.6"
 DomainSets = "0.1"
@@ -45,7 +45,7 @@ LowRankApprox = "0.2, 0.3, 0.4"
 SpecialFunctions = "0.8, 0.9"
 StaticArrays = "0.12"
 ToeplitzMatrices = "0.6"
-julia = "1.0"
+julia = "1.3"
 
 [extras]
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

appveyor.yml

@@ -1,8 +1,5 @@
 environment:
   matrix:
-  - julia_version: 1
-  - julia_version: 1.1
-  - julia_version: 1.2
   - julia_version: 1.3    
   - julia_version: nightly
 

src/ApproxFunBase.jl

@@ -58,19 +58,17 @@ import SpecialFunctions: sinpi, cospi, airy, besselh,
 
 import StaticArrays: SVector
 
-import BlockArrays: nblocks, blocksize, global2blockindex, globalrange, BlockSizes
-
 import BandedMatrices: bandrange, bandshift,
                         inbands_getindex, inbands_setindex!, bandwidth, AbstractBandedMatrix,
                         colstart, colstop, colrange, rowstart, rowstop, rowrange,
                         bandwidths, _BandedMatrix, BandedMatrix
 
+import BlockArrays: blocksize, block, blockaxes, blockindex                      
 import BlockBandedMatrices: blockbandwidth, blockbandwidths, blockcolstop, blockcolrange,
                             blockcolstart, blockrowstop, blockrowstart, blockrowrange,
                             subblockbandwidth, subblockbandwidths, _BlockBandedMatrix,
                             _BandedBlockBandedMatrix, BandedBlockBandedMatrix, BlockBandedMatrix,
-                            isblockbanded, isbandedblockbanded, bb_numentries, BlockBandedSizes,
-                            BandedBlockBandedSizes
+                            isblockbanded, isbandedblockbanded, bb_numentries, BlockBandedSizes
 
 import FillArrays: AbstractFill, getindex_value
 import LazyArrays: cache

src/Caching/bandedblockbanded.jl

@@ -3,7 +3,7 @@ function CachedOperator(::Type{BandedBlockBandedMatrix}, op::Operator)
     l,u = blockbandwidths(op)
     λ,μ = subblockbandwidths(op)
     data = BandedBlockBandedMatrix{eltype(op)}(undef,
-        (blocklengths(rangespace(op))[1:0],blocklengths(domainspace(op))[1:0]),
+        blocklengths(rangespace(op))[1:0],blocklengths(domainspace(op))[1:0],
         (l,u), (λ,μ))
 
     CachedOperator(op,data,size(data),domainspace(op),rangespace(op),(-l,u),false)
@@ -23,12 +23,10 @@ function resizedata!(B::CachedOperator{T,<:BandedBlockBandedMatrix{T}}, ::Colon,
         rows = blocklengths(rangespace(B.op))[1:J+l]
         cols = blocklengths(domainspace(B.op))[1:J]
 
-        bs = BandedBlockBandedSizes(rows, cols, l, u, λ, μ)
-
         # B.data = _BandedBlockBandedMatrix(PseudoBlockArray
 
-        blocks = PseudoBlockArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), bs.data_block_sizes)
-        B.data = _BandedBlockBandedMatrix(blocks, bs)
+        blocks = PseudoBlockArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), rows, cols)
+        B.data = _BandedBlockBandedMatrix(blocks, rows, cols, (l, u), (λ, μ))
 
         jr=B.datasize[2]+1:col
         kr=colstart(B.data,jr[1]):colstop(B.data,jr[end])
@@ -55,14 +53,7 @@ function resizedata!(B::CachedOperator{T,<:BandedBlockBandedMatrix{T}},n::Intege
     K = Int(block(rangespace(B),n))
     rows = blocklengths(rangespace(B.op))[1:K]
 
-    b_bs = BlockSizes((BlockArrays._cumul_vec(rows), B.data.block_sizes.block_sizes.cumul_sizes[2]))
-
-
-    bs = BandedBlockBandedSizes(b_bs, B.data.block_sizes.data_block_sizes,
-                                l, u, λ, μ)
-
-
-    B.data = _BandedBlockBandedMatrix(B.data.data, bs)
+    B.data = _BandedBlockBandedMatrix(B.data.data, blockedrange(rows), (l,u), (λ,μ))
     B.datasize = (n,B.datasize[2])
 
     B

src/Caching/blockbanded.jl

@@ -6,7 +6,7 @@
 function default_BlockBandedMatrix(S::Operator)
     ret = BlockBandedMatrix(Zeros, S)
 
-    @inbounds for J=Block(1):Block(nblocks(ret,2)), K=blockcolrange(ret,Int(J))
+    @inbounds for J=blockaxes(ret,2), K=blockcolrange(ret,Int(J))
         ret[K,J] = view(S,K,J)
     end
     ret
@@ -71,7 +71,7 @@ function CachedOperator(::Type{BlockBandedMatrix},op::Operator;padding::Bool=fal
     l,u=blockbandwidths(op)
     padding && (u+=l+diagblockshift(op))
     data=BlockBandedMatrix{eltype(op)}(undef,
-                                        (Vector{Int}(), Vector{Int}()),
+                                        Vector{Int}(), Vector{Int}(),
                                         (l,u))
     CachedOperator(op,data,(0,0),domainspace(op),rangespace(op),(-l,u),padding)
 end
@@ -251,17 +251,16 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
      bs = R.block_sizes
 
      for j =QR.ncols+1 : col   # first column of block
-         bi = global2blockindex(bs, (j, j)) # converts from global indices to block indices
-         K1, J1 = bi.I  # this is the diagonal block corresponding to j
-         κ, ξ = bi.α
+         bi = findblockindex.(bs.axes, (j, j)) # converts from global indices to block indices
+         K1, J1 = Int.(block.(bi))  # this is the diagonal block corresponding to j
+         κ, ξ = blockindex.(bi)
 
          st = bs.block_strides[J1]  # the stride of the matrix
          shft = bs.block_starts[K1,J1]-1 + st*(ξ-1) + κ-1 # the index of the pointer to the j, j entry
 
 
          K_CS = Int(blockcolstop(R,J1)) # last row in J-th blockcolumn
-         k_end = globalrange(bs, (K_CS, J1))[1][end]
-
+         k_end = last(bs.axes[1][Block(K_CS)])
 
          w_j = W.cols[j]  # the data index  for the j-th column of W
          wp = w+sz*(w_j-1)          # j-th column of W
@@ -278,7 +277,7 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
          # scale rest of columns in first block
          # for ξ_2 = 2:
 
-         for ξ_2 = ξ:blocksize(bs, 2, J1)
+         for ξ_2 = ξ:length(bs.axes[2][Block(J1)]) 
              # we now apply I-2v*v' in place
              r_sh = r+sz*(shft + st*(ξ_2-ξ)) # the pointer the (j,ξ_2)-th entry
              dt = BandedMatrices.dot(M, wp, 1, r_sh, 1)
@@ -288,7 +287,7 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
          for J = J1+1:min(K1+u,J_end)
              st = bs.block_strides[J]
              shft = bs.block_starts[K1,J] + κ-2 # the index of the pointer to the j, j entry
-             for ξ_2 = 1:blocksize(bs.block_sizes, 2, J)
+             for ξ_2 = axes(bs.axes[2][Block(J)],1)
                  # we now apply I-2v*v' in place
                  # r_sh = r+sz*(shft + st*(ξ_2-1)) # the pointer the (j,ξ_2)-th entry
 

src/Fun.jl

@@ -244,7 +244,7 @@ extrapolate(f::Fun,x,y,z...) = extrapolate(f.coefficients,f.space,Vec(x,y,z...))
 values(f::Fun,dat...) = itransform(f.space,f.coefficients,dat...)
 points(f::Fun) = points(f.space,ncoefficients(f))
 ncoefficients(f::Fun) = length(f.coefficients)
-nblocks(f::Fun) = block(space(f),ncoefficients(f)).n[1]
+blocksize(f::Fun) = (block(space(f),ncoefficients(f)).n[1],)
 
 function stride(f::Fun)
     # Check only for stride 2 at the moment

src/Operators/Operator.jl

@@ -85,8 +85,8 @@ macro functional(FF)
 end
 
 
-nblocks(A::Operator,k) = k==1 ? length(blocklengths(rangespace(A))) : length(blocklengths(domainspace(A)))
-nblocks(A::Operator) = (nblocks(A,1),nblocks(A,2))
+blocksize(A::Operator,k) = k==1 ? length(blocklengths(rangespace(A))) : length(blocklengths(domainspace(A)))
+blocksize(A::Operator) = (blocksize(A,1),blocksize(A,2))
 
 
 Base.size(A::Operator) = (size(A,1),size(A,2))
@@ -247,8 +247,8 @@ defaultgetindex(A::Operator,k,j) = view(A,k,j)
 # TODO: finite dimensional blocks
 blockcolstart(A::Operator,J::Integer) = Block(max(1,J-blockbandwidth(A,2)))
 blockrowstart(A::Operator,K::Integer) = Block(max(1,K-blockbandwidth(A,1)))
-blockcolstop(A::Operator,J::Integer) = Block(min(J+blockbandwidth(A,1),nblocks(A,1)))
-blockrowstop(A::Operator,K::Integer) = Block(min(K+blockbandwidth(A,2),nblocks(A,2)))
+blockcolstop(A::Operator,J::Integer) = Block(min(J+blockbandwidth(A,1),blocksize(A,1)))
+blockrowstop(A::Operator,K::Integer) = Block(min(K+blockbandwidth(A,2),blocksize(A,2)))
 
 blockrows(A::Operator,K::Integer) = blockrange(rangespace(A),K)
 blockcols(A::Operator,J::Integer) = blockrange(domainspace(A),J)
@@ -681,12 +681,12 @@ BandedMatrix(::Type{Zeros}, V::Operator) = BandedMatrix(Zeros{eltype(V)}(size(V)
 Matrix(::Type{Zeros}, V::Operator) = Matrix(Zeros{eltype(V)}(size(V)))
 BandedBlockBandedMatrix(::Type{Zeros}, V::Operator) =
     BandedBlockBandedMatrix(Zeros{eltype(V)}(size(V)),
-                            (blocklengths(rangespace(V)), blocklengths(domainspace(V))),
+                            blocklengths(rangespace(V)), blocklengths(domainspace(V)),
                             blockbandwidths(V), subblockbandwidths(V))
 BlockBandedMatrix(::Type{Zeros}, V::Operator) =
     BlockBandedMatrix(Zeros{eltype(V)}(size(V)),
-                      (AbstractVector{Int}(blocklengths(rangespace(V))),
-                       AbstractVector{Int}(blocklengths(domainspace(V)))),
+                      AbstractVector{Int}(blocklengths(rangespace(V))),
+                       AbstractVector{Int}(blocklengths(domainspace(V))),
                       blockbandwidths(V))
 RaggedMatrix(::Type{Zeros}, V::Operator) =
     RaggedMatrix(Zeros{eltype(V)}(size(V)),

src/Operators/SubOperator.jl

@@ -231,7 +231,7 @@ function BandedBlockBandedMatrix(::Type{Zeros}, S::SubOperator)
     rows,cols = blocklengths(rangespace(S)), blocklengths(domainspace(S))
 
     BandedBlockBandedMatrix(Zeros{eltype(KO)}(sum(rows),sum(cols)),
-                                (rows,cols), (l,u), (λ-jsh,μ+ksh))
+                                rows,cols, (l,u), (λ-jsh,μ+ksh))
 end
 
 function BandedBlockBandedMatrix(::Type{Zeros}, S::SubOperator{T,B,Tuple{BlockRange1,BlockRange1}}) where {T,B}
@@ -250,7 +250,7 @@ function BandedBlockBandedMatrix(::Type{Zeros}, S::SubOperator{T,B,Tuple{BlockRa
     KJR = blocklengthrange(dt,JR)
 
     BandedBlockBandedMatrix(Zeros{eltype(KO)}(sum(KBR),sum(KJR)),
-                                (AbstractVector{Int}(KBR),AbstractVector{Int}(KJR)), (l+bl_sh,u-bl_sh), (λ,μ))
+                                AbstractVector{Int}(KBR),AbstractVector{Int}(KJR), (l+bl_sh,u-bl_sh), (λ,μ))
 end
 
 

src/Operators/general/InterlaceOperator.jl

@@ -97,7 +97,7 @@ function InterlaceOperator(ops::AbstractMatrix{Operator{T}},ds::Space,rs::Space)
     dsi = interlacer(ds)
     rsi = interlacer(rs)
 
-    if size(ops,2) == p && all(isbanded,ops) &&# only support nblocks 1 for now
+    if size(ops,2) == p && all(isbanded,ops) &&# only support blocksize (1,) for now
             all(i->isa(i,AbstractFill) && getindex_value(i) == 1, dsi.blocks) &&
             all(i->isa(i,AbstractFill) && getindex_value(i) == 1, rsi.blocks)
         l,u = 0,0
@@ -393,19 +393,19 @@ function blockbanded_interlace_convert!(S,ret)
     l,u=blockbandwidths(S)::Tuple{Int,Int}
 
     M = map(op -> begin
-                KR_size = Block.(Int(first(KR)):min(Int(last(KR)),nblocks(op,1)))
-                JR_size = Block.(Int(first(JR)):min(Int(last(JR)),nblocks(op,2)))
+                KR_size = Block.(Int(first(KR)):min(Int(last(KR)),blocksize(op,1)))
+                JR_size = Block.(Int(first(JR)):min(Int(last(JR)),blocksize(op,2)))
                 BlockBandedMatrix(view(op, KR_size, JR_size))
             end, parent(S).ops)
 
-    for J=Block(1):Block(nblocks(ret,2)),K=blockcolrange(ret,Int(J))
+    for J=blockaxes(ret,2),K=blockcolrange(ret,Int(J))
         Bs=view(ret,K,J)
         j = 0
         for ξ=1:size(M,2)
             k = 0
             m = 0
             for κ=1:size(M,1)
-                if K.n[1] ≤ nblocks(M[κ,ξ],1) && J.n[1] ≤ nblocks(M[κ,ξ],2)
+                if K.n[1] ≤ blocksize(M[κ,ξ],1) && J.n[1] ≤ blocksize(M[κ,ξ],2)
                     MKJ = M[κ,ξ][K,J]::Matrix{T}
                     n,m = size(MKJ)
                     Bs[k+1:k+n,j+1:j+m] = MKJ