rustsim-spaces 0.0.1

Space implementations (grid, continuous, graph, hybrid) for rustsim
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use rustsim_core::interaction::{PositionedAgent, SpaceInteraction};
use rustsim_core::prelude::{Agent, AgentId};
use rustsim_spaces::continuous::{ContinuousSpace2D, ContinuousSpaceError};
use rustsim_spaces::graph::{GraphSpace, GraphSpaceError};
use rustsim_spaces::grid::{Grid2D, Grid2DSingle, GridError};

// --- Helper agent types ---

#[derive(Debug, Clone)]
struct GridAgent {
    id: AgentId,
    pos: (usize, usize),
}

impl Agent for GridAgent {
    fn id(&self) -> AgentId {
        self.id
    }
}

impl PositionedAgent for GridAgent {
    type Position = (usize, usize);
    fn position(&self) -> &Self::Position {
        &self.pos
    }
    fn set_position(&mut self, p: Self::Position) {
        self.pos = p;
    }
}

#[derive(Debug, Clone)]
struct GraphAgent {
    id: AgentId,
    pos: usize,
}

impl Agent for GraphAgent {
    fn id(&self) -> AgentId {
        self.id
    }
}

impl PositionedAgent for GraphAgent {
    type Position = usize;
    fn position(&self) -> &Self::Position {
        &self.pos
    }
    fn set_position(&mut self, p: Self::Position) {
        self.pos = p;
    }
}

// --- Grid2D OOB ---

#[test]
fn grid2d_add_oob_returns_error() {
    let mut grid = Grid2D::new(3, 3, false);
    let err = grid.add_agent((10, 10), 1);
    assert_eq!(err, Err(GridError::OutOfBounds((10, 10))));
}

#[test]
fn grid2d_remove_oob_returns_error() {
    let mut grid = Grid2D::new(3, 3, false);
    let err = grid.remove_agent((10, 10), 1);
    assert_eq!(err, Err(GridError::OutOfBounds((10, 10))));
}

#[test]
fn grid2d_remove_nonexistent_agent_returns_false() {
    let mut grid = Grid2D::new(3, 3, false);
    grid.add_agent((1, 1), 1).unwrap();
    let removed = grid.remove_agent((1, 1), 999).unwrap();
    assert!(!removed);
}

// --- Grid2DSingle OOB + Occupied ---

#[test]
fn grid2d_single_add_oob_returns_error() {
    let mut grid = Grid2DSingle::new(3, 3, false);
    let err = grid.add_agent((10, 10), 1);
    assert_eq!(err, Err(GridError::OutOfBounds((10, 10))));
}

#[test]
fn grid2d_single_add_occupied_returns_error() {
    let mut grid = Grid2DSingle::new(3, 3, false);
    grid.add_agent((1, 1), 1).unwrap();
    let err = grid.add_agent((1, 1), 2);
    assert_eq!(err, Err(GridError::Occupied((1, 1))));
}

// --- Grid2D via SpaceInteraction ---

#[test]
fn grid2d_space_interaction_add_oob() {
    let mut grid = Grid2D::new(3, 3, false);
    let agent = GridAgent {
        id: 1,
        pos: (99, 99),
    };
    let err = SpaceInteraction::<GridAgent>::add_agent(&mut grid, &agent);
    assert!(err.is_err());
}

// --- ContinuousSpace2D OOB ---

#[test]
fn continuous_space_oob_non_periodic() {
    use rustsim_spaces::continuous::ContinuousPos;

    let mut space = ContinuousSpace2D::new(10.0, 10.0, false, 2.0).unwrap();
    let err = space.move_agent_pos(1, ContinuousPos::new(-1.0, 5.0));
    assert_eq!(err, Err(ContinuousSpaceError::OutOfBounds));
}

// --- GraphSpace invalid node ---

#[test]
fn graph_space_add_agent_invalid_node() {
    let mut graph = GraphSpace::new(3);
    let agent = GraphAgent { id: 1, pos: 99 };
    let err = SpaceInteraction::<GraphAgent>::add_agent(&mut graph, &agent);
    assert_eq!(err, Err(GraphSpaceError::InvalidNode(99)));
}

#[test]
fn graph_space_remove_agent_invalid_node() {
    let mut graph = GraphSpace::new(3);
    let agent = GraphAgent { id: 1, pos: 99 };
    let err = SpaceInteraction::<GraphAgent>::remove_agent(&mut graph, &agent);
    assert_eq!(err, Err(GraphSpaceError::InvalidNode(99)));
}