Struct Hex2D 

pub struct Hex2D { /* private fields */ }

A two-dimensional hexagonal lattice with axial coordinates.

Each cell has coordinate [q, r] where 0 <= q < cols and 0 <= r < rows. The grid uses pointy-top orientation with six neighbours per interior cell. Boundary behavior is Absorb (edge cells have fewer neighbours).

Distance is cube distance: max(|dq|, |dr|, |dq + dr|), which equals the graph geodesic on the hex grid.

Canonical ordering is r-then-q: outer loop over r, inner loop over q.

Examples

use murk_space::{Hex2D, Space};

let hex = Hex2D::new(5, 5).unwrap();
assert_eq!(hex.rows(), 5);
assert_eq!(hex.cols(), 5);
assert_eq!(hex.cell_count(), 25);
assert_eq!(hex.ndim(), 2);

// Interior cell has 6 neighbours.
let interior: murk_core::Coord = vec![2i32, 2].into();
assert_eq!(hex.neighbours(&interior).len(), 6);

// Corner cell has fewer neighbours (absorb boundary).
let corner: murk_core::Coord = vec![0i32, 0].into();
assert_eq!(hex.neighbours(&corner).len(), 2);

// Cube distance between adjacent cells is 1.
let a: murk_core::Coord = vec![2i32, 1].into();
let b: murk_core::Coord = vec![3i32, 1].into();
assert_eq!(hex.distance(&a, &b), 1.0);

Implementations

impl Hex2D

pub const MAX_DIM: u32

Maximum dimension size: coordinates use i32, so each axis must fit.

pub fn new(rows: u32, cols: u32) -> Result<Self, SpaceError>

Create a new hex grid with rows * cols cells.

Returns Err(SpaceError::EmptySpace) if either dimension is 0, or Err(SpaceError::DimensionTooLarge) if either exceeds i32::MAX.

pub fn rows(&self) -> u32

Number of rows.

pub fn cols(&self) -> u32

Number of columns.

pub fn is_empty(&self) -> bool

Always returns false — construction rejects empty grids.

Trait Implementations

impl Clone for Hex2D

fn clone(&self) -> Hex2D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hex2D

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

Formats the value using the given formatter.

impl Space for Hex2D

fn ndim(&self) -> usize

Number of spatial dimensions.

fn cell_count(&self) -> usize

Total number of cells in the space.

fn neighbours(&self, coord: &Coord) -> SmallVec<[Coord; 8]>

Enumerate the neighbors of a cell.

fn max_neighbour_degree(&self) -> usize

Maximum neighbor-list length over all cells in this space.

fn distance(&self, a: &Coord, b: &Coord) -> f64

Graph-geodesic distance between two cells.

fn compile_region(&self, spec: &RegionSpec) -> Result<RegionPlan, SpaceError>

Compile a region specification into a plan for O(1) lookups.

fn canonical_ordering(&self) -> Vec<Coord>

All cells in deterministic canonical order.

fn canonical_rank(&self, coord: &Coord) -> Option<usize>

Position of a coordinate in the canonical ordering.

fn canonical_rank_slice(&self, coord: &[i32]) -> Option<usize>

Position of a coordinate slice in the canonical ordering.

fn instance_id(&self) -> SpaceInstanceId

Unique instance identifier for this space object.

fn topology_eq(&self, other: &dyn Space) -> bool

Returns true if self and other are topologically equivalent: same concrete type and identical behavioral parameters.

fn iter_region<'a>( &'a self, plan: &'a RegionPlan, ) -> Box<dyn Iterator<Item = Coord> + 'a>

Iterate over the cells in a compiled region.

fn map_coord_to_tensor_index( &self, coord: &Coord, plan: &RegionPlan, ) -> Option<usize>

Map a coordinate to its flat tensor index within a compiled region.