Spiraling outwards iterator

General Usage
1

Hey, I was looking for an iterator that spirals outward a given point. By that I stumbled over a Rosetta Code Challenge seeing that it is outdated (old iterator protocol) and that it goes inward clockwise. Thus it didn’t help. I’m telling here nevertheless because someone might want to challenge himself.

Now, using the algorithm from a StackOverflow question I came up with my own spiraling counter-clockward outwards iterator:

struct SpiralIterator
    center::CartesianIndex{2} #EDIT: {2} added according to suggestion of @jlperla 
end

function Base.iterate(iter::SpiralIterator, state=(0,0,-1,1))#x,y,d,m
    x, y, d, m = state
    2 * x * d < m && return (iter.center+CartesianIndex(x,y), (x+d, y, d, m))
    2 * y * d < m && return (iter.center+CartesianIndex(x,y), (x, y+d, d, m))
    return Base.iterate(iter, (x, y, -d, m+1))
end

Base.IteratorSize(::SpiralIterator) = Base.IsInfinite()

I wanted to ask if that’s idiomatic Julia and if you see anything to tweak (especially because the first condition is evaluated twice as often as the second one).

1 Like
2

I don’t think that center::CartesianIndex would lead to a concrete type in your structure. If not, you will need to make it parametric with center::T and T <: CartesianIndex or something along those lines

1 Like
3

What about CartesianIndex{2} as the algorithm only works for 2d anyway?

4

I think that is right. If it only works with {2} then you shouldn’t make it generic.

Note that a good way to check if things are concrete is:

julia> typeof(CartesianIndex)
UnionAll

julia> typeof(CartesianIndex{2})
DataType

The UnionAll means there are some parametric parameter, and hence will not be a concrete type if used in a struct. DataType means A-OK, and other things usually mean it is an abstract type.