Create a N-dimensional grid

[Tortar]

I have seen many proposals in PRs to extend the Grid so that it can tackle more than 2 dimensions, I think that trying to do it with Numpy should be rather doable, I can work on it if others think it's a good idea, as a start making it as a separate class from the 2d-case could be rather safe in terms of compatibility, what do you guys think about it?

[rht]

SGTM. Numpy arrays are rather slow for small grid size, but having an N-dimensional grid implementation, albeit slow, is better than none. You can check how Agents.jl does it, if they have some perf optimization.

[rht]

However, one advantage of using NumPy arrays is that augmenting the code via Numba/Cython is easier than with list-of-lists. Cython has typed memoryview, which Python counterpart is a NumPy array.

[Tortar]

Exactly what I thought, NumPy is a good fit for those libraries

[Corvince]

I have another idea how we could create an n-dimensional grid, I will write down that idea in this thread next week :)

But we should also consider how common and/or useful n dimensional grids really are.

[rht]

There is definitely a use case for 3D grids. The question is whether to implement it as mainly a 3D grid, or an N-dimensional grid where N = 3.
It's trivial to create N-dimensional grid in Agents.jl. It is even shown in the doc.
But I suppose because Julia is more expressive than Python.

[Datseris]

@rht An additional argument for higher dimensional spaces can be that some of the dimensions do not necessarily have to be spatial; they can be "ranks". or "power levels". Something that would still make sense to search for "neighbors" in. E.g., get agents that are not only near you, but also in a similar "power level". This could be done with only a 2D grid, and then filtering based on a "power" agent property. But it can also be done in 3D space where the 3rd dimension is "power".

Example: https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/examples/battle/ (unfortunately the example is broken because I haven't managed to update it yet to newer Agents.jl version, but I hope the model description will give you the rough idea)

Note that in AGents.jl there is a clear performance benefit in doing this in a 3D space rather than filtering. We can dispatch the search function so that if radious is a tuple (r1, r2, r3), a different search range is used across dimensions. This way we avoid filtering alltogether. I am not sure how one would implement this in Mesa.

[rht]

I see, in addition to the performance, the mental model to imagine a 2+1 space is more illustrative than having to separately think of a non-visual filter for similar "power level". This reminds me of visualizing degree of freedoms in the analogy arithmetic in thought vector.

Regarding with implementing the radius as a tuple in Mesa, it should be possible to do it by hand for now (for 2D and 3D), by specifying the radius in

mesa/mesa/space.py

Lines 278 to 279 in b2f642f

	x_range = range(x - radius, x + radius + 1)
	y_range = range(y - radius, y + radius + 1)

for each axis.

For N dimension, we would have to emulate Agents.jl implementation (https://github.com/JuliaDynamics/Agents.jl/blob/5156fa95e9d7230a142ce3d84839164f5bf8a9b0/src/spaces/grid_multi.jl#L234-L250) that loops through all stored ids and then selecting the ones that are within the bound range. If I read that code correctly, it skips calculating nearby_positions, and instead it goes through each agents' positions. This may be faster when the number of agents is relatively small compared to the bounding volume.