indices1 -> axes1

new iteration

Author: dlfivefifty

src/BlockArrays.jl

@@ -18,9 +18,9 @@ export PseudoBlockArray, PseudoBlockMatrix, PseudoBlockVector, PseudoBlockVecOrM
 export undef_blocks, undef
 
 import Base: @propagate_inbounds, Array, to_indices, to_index, indices,
-            unsafe_indices, indices1, first, last, size, length, unsafe_length,
+            unsafe_indices, first, last, size, length, unsafe_length,
             unsafe_convert,
-            getindex, show, start, next, done,
+            getindex, show,
             broadcast, eltype, convert, broadcast,
             @_inline_meta, _maybetail, tail, @_propagate_inbounds_meta, reindex,
             RangeIndex, Int, Integer, Number,
@@ -29,10 +29,11 @@ import Base: @propagate_inbounds, Array, to_indices, to_index, indices,
 import Compat: copyto!, axes
 
 if VERSION < v"0.7-"
-    import Base: colon, iteratorsize
+    import Base: colon, iteratorsize, indices1, start, next, done
     const parentindices = parentindexes
+    const axes1 = indices1
 else
-    import Base: (:), IteratorSize, iterate
+    import Base: (:), IteratorSize, iterate, axes1
     import Base.Broadcast: broadcasted, DefaultArrayStyle
 end
 

src/blockindexrange.jl

@@ -29,19 +29,32 @@ end
 first(iter::BlockIndexRange) = BlockIndex(iter.block.n, map(first, iter.indices))
 last(iter::BlockIndexRange)  = BlockIndex(iter.block.n, map(last, iter.indices))
 
-
-@inline function start(iter::BlockIndexRange)
-    iterfirst, iterlast = first(iter), last(iter)
-    if any(map(>, iterfirst.α, iterlast.α))
-        return BlockIndex(iterlast.I, iterlast.α .+ 1)
+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
     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])
-
 size(iter::BlockIndexRange) = map(dimlength, first(iter).α, last(iter).α)
 length(iter::BlockIndexRange) = prod(size(iter))
 

src/blockrange.jl

@@ -38,15 +38,15 @@ else
 end
 
 # AbstractArray implementation
-axes(iter::BlockRange{N,R}) where {N,R} = map(Base.indices1, iter.indices)
+axes(iter::BlockRange{N,R}) where {N,R} = map(axes1, iter.indices)
 Base.IndexStyle(::Type{BlockRange{N,R}}) where {N,R} = IndexCartesian()
 @inline function Base.getindex(iter::BlockRange{N,<:NTuple{N,Base.OneTo}}, I::Vararg{Int, N}) where {N}
     @boundscheck checkbounds(iter, I...)
     Block(I)
 end
 @inline function Base.getindex(iter::BlockRange{N,R}, I::Vararg{Int, N}) where {N,R}
     @boundscheck checkbounds(iter, I...)
-    Block(I .- first.(Base.indices1.(iter.indices)) .+ first.(iter.indices))
+    Block(I .- first.(axes1.(iter.indices)) .+ first.(iter.indices))
 end
 
 

src/views.jl

@@ -16,7 +16,7 @@ end
 Block(bs::BlockSlice{<:Block}) = bs.block
 
 
-for f in (:axes, :unsafe_indices, :indices1, :first, :last, :size, :length,
+for f in (:axes, :unsafe_indices, :axes1, :first, :last, :size, :length,
           :unsafe_length, :start)
     @eval $f(S::BlockSlice) = $f(S.indices)
 end

test/runtests.jl

@@ -1,7 +1,10 @@
-using BlockArrays, Compat, Compat.Test
+using BlockArrays, Compat.LinearAlgebra, Compat, Compat.Test
 
 if VERSION < v"0.7-"
     const parentindices = parentindexes
+    const axes1 = Base.indices1
+else
+    import Base: axes1
 end
 
 include("test_blockindices.jl")

test/test_blockviews.jl

@@ -11,7 +11,7 @@
     @test step(b) == 1
     @test Base.unsafe_length(b) == 2
     @test Compat.axes(b) == (Base.OneTo(2),)
-    @test Base.indices1(b) == Base.OneTo(2)
+    @test axes1(b) == Base.OneTo(2)
     @test Base.unsafe_indices(b) == (Base.OneTo(2),)
     @test size(b) == (2,)
     @test collect(b) == [2,3]
@@ -112,5 +112,5 @@ end
 @testset "block indx range of block range" begin
      A = PseudoBlockArray(collect(1:6), 1:3)
      V = view(A, Block.(2:3))
-     @test view(V, Block(2)[1:2]) == [4,5] 
+     @test view(V, Block(2)[1:2]) == [4,5]
 end