Struct GridGeometry 

pub struct GridGeometry {
    pub coord_dims: Vec<u32>,
    pub coord_strides: Vec<usize>,
    pub ndim: usize,
    pub all_wrap: bool,
    pub connectivity: GridConnectivity,
}

Extracted grid geometry for fast interior/boundary dispatch.

If the space is a known grid type, we extract its dimensions and strides per coordinate index. This enables:

• O(1) is_interior check (no BFS, no bounds-check per cell)
• Direct stride arithmetic for the fast gather path

coord_dims\[i\] is the valid range for coord\[i\] (0..coord_dims[i]). coord_strides\[i\] is the stride for coord\[i\] in canonical rank.

Fields

coord_dims: Vec<u32>

Valid range per coordinate index: coord[i] must be in 0..coord_dims[i].

coord_strides: Vec<usize>

Stride per coordinate index for canonical rank computation.

ndim: usize

Number of spatial dimensions.

all_wrap: bool

Whether all boundaries wrap (torus topology → all positions interior).

connectivity: GridConnectivity

Connectivity type for graph-distance computation.

Implementations

impl GridGeometry

pub fn from_space(space: &dyn Space) -> Option<Self>

Try to extract grid geometry from a &dyn Space via downcast.

Returns Some for Square4, Square8, Hex2D (all 2D grids). Returns None for Line1D, Ring1D, ProductSpace (heterogeneous), or any unknown Space implementation.

pub fn canonical_rank(&self, coord: &[i32]) -> usize

Compute the canonical rank of a coordinate using stride arithmetic.

For a 2D grid with dims [R, C], coord [a, b]: rank = a * strides[0] + b * strides[1].

pub fn in_bounds(&self, coord: &[i32]) -> bool

Check if a coordinate is within the grid bounds.

pub fn is_interior(&self, center: &[i32], radius: u32) -> bool

O(1) check: is the agent at center fully interior for a given radius?

An agent is interior if all cells within radius of center are in-bounds on every coordinate axis: radius <= center[i] and center[i] + radius < coord_dims[i] for all i.

For wrapped spaces (all_wrap == true), every position is interior.

pub fn graph_distance(&self, relative: &[i32]) -> u32

Compute the graph distance from origin for a relative coordinate.

This uses the distance metric appropriate for the grid connectivity:

• FourWay: Manhattan distance |d0| + |d1| + ...
• EightWay: Chebyshev distance max(|d0|, |d1|, ...)
• Hex: Cube distance max(|dq|, |dr|, |dq + dr|) (axial coords)

Trait Implementations

impl Clone for GridGeometry

fn clone(&self) -> GridGeometry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GridGeometry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.