Accessing an array some elements at a time and wrapping round to the beginning

Question

I have a simple question that should have a simple answer but I can't think of it yet. I want to process an array, a certain number of elements at a time, and wrapping round to the beginning.

Here's a diagram showing when n is 10 and three elements are wanted each time:

My attempts to write a simple iteration so far have failed: using % n gives me zeros, which don't work with Julia's one-indexing... :)

Answer 1

The mod1 function is provided to allow the behaviour you desire:

julia> mod1(1, 5)
1

julia> mod1(3, 5)
3

julia> mod1(5, 5)
5

julia> mod1(6, 5)
1

It's pretty straightforward to make a mod-indexed function:

modindex(A, i) = A[mod1(i, length(A))]

Or even your own mod-indexed array type:

julia> immutable CircArray{T} <: AbstractArray{T,1}
           xs::Vector{T}
       end

julia> Base.size(x::CircArray) = (length(x.xs),)

julia> Base.getindex(x::CircArray, i) = x.xs[mod1(i, length(x.xs))]

julia> A = CircArray([1:2:10;])
CircArray{Array{Int64,1}}([1,3,5,7,9])

julia> A[0]
9

julia> A[5]
9

julia> A[7]
3

It is not too difficult to implement slicing on top of this. As DNF mentioned in a comment, a clean and concise solution is

modindex(A, i) = A[mod1.(i, end)]

or the equivalent for getindex, which handles both scalar indexing and slicing.

---

Edit: Since your question mentioned iteration, I figure I'd provide a more general solution that also works on non-arrays for iteration purposes, using only the functional iterables in Base:

julia> threes(A) = let cy = cycle(A)
           take(zip(cy, drop(cy, 1), drop(cy, 2)), length(A))
       end
threes (generic function with 1 method)

julia> for (a, b, c) in threes([1, 2, 3, 4, 5])
           println(a, b, c)
       end
123
234
345
451
512