Struct GraphSpace 

pub struct GraphSpace { /* private fields */ }

A graph-based discrete space mirroring Julia Agents.jl GraphSpace.

Each node can hold an arbitrary number of agents. Agents move between nodes along edges. Distance is measured in graph hops.

Supports both directed and undirected graphs. Edges and vertices can be added/removed dynamically at runtime.

Example: building floor graph

  [Floor1-RoomA] --edge-- [Floor1-Corridor] --edge-- [Floor1-RoomB]
                               |
                             (stairs)
                               |
  [Floor2-RoomA] --edge-- [Floor2-Corridor] --edge-- [Floor2-RoomB]

Each room/corridor/stairwell is a node. Edges connect adjacent spaces.

Implementations

impl GraphSpace

pub fn new(n: usize) -> Self

Create an undirected graph with n nodes and no edges.

pub fn new_directed(n: usize, directed: bool) -> Self

Create a graph with n nodes. If directed is true, edges are one-way.

pub fn num_vertices(&self) -> usize

Number of nodes in the graph.

pub fn num_edges(&self) -> usize

Number of edges in the graph.

For undirected graphs, each edge is counted once (not twice).

pub fn is_directed(&self) -> bool

Whether the graph is directed.

pub fn add_vertex(&mut self) -> GraphPos

Add a new vertex and return its index.

pub fn rem_vertex(&mut self, n: GraphPos) -> bool

Remove a vertex by swapping with the last vertex (matches Graphs.jl behavior). All agents at the removed vertex must be removed beforehand. Returns true if successful.

pub fn add_edge(&mut self, a: GraphPos, b: GraphPos) -> bool

Add an edge from a to b. For undirected graphs, also adds b to a.

pub fn rem_edge(&mut self, a: GraphPos, b: GraphPos) -> bool

Remove an edge from a to b.

pub fn neighbors_out(&self, n: GraphPos) -> &[GraphPos]

Outgoing neighbors of a node (slice reference, no allocation).

pub fn neighbors_in(&self, n: GraphPos) -> &[GraphPos]

Incoming neighbors of a node (slice reference, no allocation).

pub fn neighbors_all(&self, n: GraphPos) -> Vec<GraphPos>

All neighbors (union of incoming and outgoing), deduplicated.

pub fn neighbors(&self, n: GraphPos, kind: NeighborType) -> Vec<GraphPos>

Get neighbors according to a NeighborType selector.

pub fn ids_in_position(&self, n: GraphPos) -> &[AgentId]

Agent IDs stored at a given node.

pub fn positions(&self) -> Range<usize>

All valid node indices.

pub fn nearby_positions( &self, pos: GraphPos, r: usize, kind: NeighborType, ) -> Vec<GraphPos>

Find all node indices reachable within r hops via BFS, excluding the origin.

pub fn nearby_agent_ids( &self, pos: GraphPos, r: usize, kind: NeighborType, ) -> Vec<AgentId>

Find all agent IDs within r hops, including agents at the origin node.

Trait Implementations

impl Clone for GraphSpace

fn clone(&self) -> GraphSpace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphSpace

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

Formats the value using the given formatter.

impl<A> SpaceInteraction<A> for GraphSpace

where A: PositionedAgent<Position = GraphPos>,

type Error = GraphSpaceError

Error type for space operations.

fn random_position<R: RngCore>(&self, rng: &mut R) -> A::Position

Generate a random valid position within this space.

fn add_agent(&mut self, agent: &A) -> Result<(), Self::Error>

Register an agent with the space at its current position.

fn remove_agent(&mut self, agent: &A) -> Result<(), Self::Error>

Deregister an agent from the space.

fn nearby_ids(&self, position: &A::Position, radius: usize) -> Vec<AgentId>

Return all agent IDs within radius of position.

impl Space for GraphSpace