Release 0.6.2

Author: Routhleck

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "canns-lib"
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Sichao He <sichaohe@outlook.com>"]

example/trajectory_comparison.py

@@ -51,6 +51,41 @@ def plot_environment(ax, state):
     ax.set_aspect("equal")
 
 
+def _describe_history_shapes(case_name: str, label: str, history: dict[str, Any]) -> None:
+    """Log the shapes of history entries for quick inspection."""
+
+    history = dict(history)
+    print(f"{case_name} - {label} history shapes:")
+    if not history:
+        print("  <empty>")
+        return
+
+    for key in sorted(history):
+        value = history[key]
+        if value is None:
+            print(f"  {key}: None")
+            continue
+        arr = np.asarray(value)
+        print(f"  {key}: {arr.shape}")
+
+
+def _summarize_state_deltas(case_name: str, ra_states: np.ndarray, our_states: np.ndarray) -> None:
+    if ra_states.shape != our_states.shape:
+        print(f"{case_name} - state shape mismatch; cannot summarise deltas")
+        return
+
+    diff = ra_states - our_states
+    if diff.ndim == 1:
+        distances = np.abs(diff)
+    else:
+        distances = np.linalg.norm(diff, axis=diff.ndim - 1)
+
+    print(
+        f"{case_name} - state Δ summary: mean={distances.mean():.6g}, "
+        f"median={np.median(distances):.6g}, max={distances.max():.6g}"
+    )
+
+
 def _split_objects(env_params: dict) -> tuple[dict, list[Any]]:
     ra_params = dict(env_params)
     raw_objects = list(ra_params.pop("objects", []) or [])
@@ -113,7 +148,6 @@ def run_case(name: str, env_params: dict, agent_configs: Sequence[dict], steps:
 
     if init_pos is not None or init_vel is not None:
         ra_agent.reset_history()
-        ra_agent.save_to_history()
         our_agent.reset_history()
 
     ra_states = [ra_agent.pos.copy()]
@@ -132,6 +166,15 @@ def run_case(name: str, env_params: dict, agent_configs: Sequence[dict], steps:
     ra_states = np.array(ra_states)
     our_states = np.array(our_states)
 
+    print(f"{name} - RatInABox states shape:")
+    print(ra_states.shape)
+    print(f"{name} - canns-lib states shape:")
+    print(our_states.shape)
+
+    _summarize_state_deltas(name, ra_states, our_states)
+    _describe_history_shapes(name, "RatInABox", ra_agent.history)
+    _describe_history_shapes(name, "canns-lib", our_agent.history)
+
     # Trajectory plot
     fig, ax = plt.subplots(figsize=(5, 5))
     plot_environment(ax, our_env.render_state())
@@ -157,6 +200,18 @@ def run_case(name: str, env_params: dict, agent_configs: Sequence[dict], steps:
 if __name__ == "__main__":  # pragma: no cover
     # Scenarios roughly mirror RatInABox demos such as simple_example (uniform drift),
     # extensive_example (wall interactions), and path_integration/vector_cell notebooks.
+    const_env_size = 1.5
+    const_dt = 0.001
+    const_duration = 2.0
+    const_steps = int(round(const_duration / const_dt))
+    const_speed = 2.0
+    const_angle = (11.0 / 12.0) * np.pi
+    const_init_vel = (
+        const_speed * np.cos(const_angle),
+        const_speed * np.sin(const_angle),
+    )
+    const_init_pos = [const_env_size * 15.0 / 16.0, const_env_size * 1.0 / 16.0]
+
     cases = [
         (
             "case1_uniform",
@@ -385,5 +440,36 @@ def run_case(name: str, env_params: dict, agent_configs: Sequence[dict], steps:
         ),
     ]
 
+    for seed in [0]:
+        name = f"case9_constant_speed_seed{seed}"
+        cases.append(
+            (
+                name,
+                {
+                    "dimensionality": "2D",
+                    "boundary_conditions": "solid",
+                    "scale": const_env_size,
+                    "aspect": 1.0,
+                },
+                (
+                    {
+                        "params": {
+                            "dt": const_dt,
+                            "speed_mean": const_speed,
+                            "speed_std": 0.0,
+                            "speed_coherence_time": 10.0,
+                            "rotational_velocity_std": np.deg2rad(40.0),
+                        },
+                        "rng_seed": seed,
+                        "init_pos": const_init_pos,
+                        # "init_vel": list(const_init_vel),
+                    },
+                    {},
+                ),
+                const_steps,
+                const_dt,
+            )
+        )
+
     for case in cases:
         run_case(*case)

python/canns_lib/_version.py

@@ -1,3 +1,3 @@
 """Project-wide version string."""
 
-__version__ = "0.6.1"
+__version__ = "0.6.2"

src/spatial/agent.rs

@@ -209,18 +209,21 @@ impl Agent {
         match self.dimensionality {
             Dimensionality::D1 => {
                 let mut speed = self.velocity.get(0).copied().unwrap_or(0.0);
-                speed = ornstein_uhlenbeck(
+                speed += ornstein_uhlenbeck(
                     speed,
                     self.params.speed_mean,
                     self.params.speed_std,
                     self.params.speed_coherence_time,
                     dt,
                     &mut self.rng,
                 );
+                if self.params.speed_std == 0.0 {
+                    speed = self.params.speed_mean;
+                }
                 self.velocity = vec![speed];
             }
             Dimensionality::D2 => {
-                self.rotational_velocity = ornstein_uhlenbeck(
+                self.rotational_velocity += ornstein_uhlenbeck(
                     self.rotational_velocity,
                     0.0,
                     self.params.rotational_velocity_std,
@@ -231,14 +234,15 @@ impl Agent {
                 rotate_vector(&mut self.velocity, self.rotational_velocity * dt);
 
                 let speed = vector_norm(&self.velocity);
-                let mut new_speed = ornstein_uhlenbeck(
-                    speed,
-                    self.params.speed_mean,
-                    self.params.speed_std,
-                    self.params.speed_coherence_time,
-                    dt,
-                    &mut self.rng,
-                );
+                let mut new_speed = speed
+                    + ornstein_uhlenbeck(
+                        speed,
+                        self.params.speed_mean,
+                        self.params.speed_std,
+                        self.params.speed_coherence_time,
+                        dt,
+                        &mut self.rng,
+                    );
                 if self.params.speed_std == 0.0 {
                     new_speed = self.params.speed_mean;
                 }
@@ -272,7 +276,7 @@ impl Agent {
                 let ratio = drift_ratio.max(1e-6);
                 let tau = (self.params.speed_coherence_time / ratio).max(1e-6);
                 for (vel, target_val) in self.velocity.iter_mut().zip(target.iter()) {
-                    *vel = ornstein_uhlenbeck(*vel, *target_val, 0.0, tau, dt, &mut self.rng);
+                    *vel += ornstein_uhlenbeck(*vel, *target_val, 0.0, tau, dt, &mut self.rng);
                 }
             }
         }
@@ -432,7 +436,7 @@ impl Agent {
             };
         }
 
-        let mut agent = Self {
+        let agent = Self {
             dimensionality: env_state.dimensionality,
             env_state,
             params: agent_params,
@@ -452,8 +456,6 @@ impl Agent {
             history_rot: Vec::new(),
             imported: None,
         };
-
-        agent.record_history();
         Ok(agent)
     }
 
@@ -630,7 +632,6 @@ impl Agent {
         self.history_head.clear();
         self.history_distance.clear();
         self.history_rot.clear();
-        self.record_history();
     }
 
     pub fn set_position(&mut self, position: Vec<f64>) -> PyResult<()> {
@@ -710,7 +711,6 @@ impl Agent {
             self.history_head.clear();
             self.history_distance.clear();
             self.history_rot.clear();
-            self.record_history();
         }
         Ok(())
     }

src/spatial/utils.rs

@@ -39,13 +39,18 @@ pub(crate) fn ornstein_uhlenbeck(
     rng: &mut StdRng,
 ) -> f64 {
     if coherence_time <= 0.0 {
-        return drift;
+        return drift - current;
     }
+
     let theta = 1.0 / coherence_time;
-    let exp_term = (-theta * dt).exp();
-    let mean = current * exp_term + drift * (1.0 - exp_term);
-    let variance = noise_scale.powi(2) * (1.0 - exp_term * exp_term);
-    let std = variance.max(0.0).sqrt();
-    let noise: f64 = rng.sample(StandardNormal);
-    mean + std * noise
+    let drift_term = theta * (drift - current) * dt;
+
+    if noise_scale == 0.0 {
+        return drift_term;
+    }
+
+    let sigma = ((2.0 * noise_scale.powi(2)) / (coherence_time * dt)).sqrt();
+    let normal: f64 = rng.sample(StandardNormal);
+    let diffusion = sigma * normal * dt;
+    drift_term + diffusion
 }

tests/test_spatial_basic.py

@@ -58,13 +58,13 @@ def test_agent_history_and_seeded_update():
     env = spatial.Environment()
     agent = spatial.Agent(env, rng_seed=1234)
     assert agent.t == pytest.approx(0.0)
-    assert agent.history_positions().shape == (1, 2)
+    assert agent.history_positions().shape == (0, 2)
     agent.update(dt=0.05)
     assert agent.t == pytest.approx(0.05)
-    assert agent.history_positions().shape == (2, 2)
-    assert agent.history_velocities().shape == (2, 2)
-    assert agent.history_head_directions().shape == (2, 2)
-    assert agent.history_distance_travelled().shape == (2,)
+    assert agent.history_positions().shape == (1, 2)
+    assert agent.history_velocities().shape == (1, 2)
+    assert agent.history_head_directions().shape == (1, 2)
+    assert agent.history_distance_travelled().shape == (1,)
     history = agent.history
     assert set(history.keys()) == {
         "t",
@@ -74,17 +74,21 @@ def test_agent_history_and_seeded_update():
         "rot_vel",
         "distance_travelled",
     }
+    for key, value in history.items():
+        if isinstance(value, list):
+            assert len(value) == 1
     arrays = agent.history_arrays()
-    assert arrays["pos"].shape == (2, 2)
+    assert arrays["pos"].shape == (1, 2)
 
 
 def test_forced_position_and_reset_history():
     env = spatial.Environment()
     agent = spatial.Agent(env, rng_seed=42)
     agent.set_forced_next_position([0.5, 0.5])
     assert np.allclose(agent.pos, [0.5, 0.5])
-    agent.reset_history()
     assert agent.history_positions().shape == (1, 2)
+    agent.reset_history()
+    assert agent.history_positions().shape == (0, 2)
 
 
 def test_agent_init_with_explicit_state():
@@ -97,13 +101,20 @@ def test_agent_init_with_explicit_state():
     )
     assert np.allclose(agent.pos, [0.2, 0.8])
     assert np.allclose(agent.velocity, [0.0, 0.1])
-    assert agent.history_positions()[0, 0] == pytest.approx(0.2)
-    assert agent.history_velocities()[0, 1] == pytest.approx(0.1)
+    assert agent.history_positions().shape == (0, 2)
+    agent.update(dt=0.05)
+    pos_history = agent.history_positions()
+    vel_history = agent.history_velocities()
+    assert pos_history.shape == (1, 2)
+    assert vel_history.shape == (1, 2)
+    assert np.allclose(pos_history[-1], np.array(agent.pos))
+    assert np.allclose(vel_history[-1], np.array(agent.measured_velocity))
 
 
 def test_agent_set_position_velocity_updates_history():
     env = spatial.Environment()
     agent = spatial.Agent(env, rng_seed=5)
+    agent.update(dt=0.05)
     agent.set_position([0.3, 0.7])
     assert np.allclose(agent.pos, [0.3, 0.7])
     assert np.allclose(agent.history_positions()[-1], [0.3, 0.7])