oxmpl-py 0.1.0__tar.gz

oxmpl_py-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: oxmpl_py
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Summary: Python Bindings for the OxMPL Library
+Author: Junior Sundar <juniorsundar@gmail.com>
+Author-email: Junior Sundar <juniorsundar@gmail.com>
+License: BSD-3
+Requires-Python: >=3.8

oxmpl_py-0.1.0/oxmpl/Cargo.lock

@@ -0,0 +1,157 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "oxmpl"
+version = "0.1.0"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
+[[package]]
+name = "rand"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4307e30089d6fd6aff212f2da3a1f9e32f3223b1f010fb09b7c95f90f3ca1e8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]

oxmpl_py-0.1.0/oxmpl/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "oxmpl"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "oxmpl"
+crate-type = ["lib"]
+
+[dependencies]
+rand = "0.9.1"

oxmpl_py-0.1.0/oxmpl/src/base/error.rs

@@ -0,0 +1,89 @@
+use std::{error, fmt};
+
+#[derive(Debug, PartialEq)]
+pub enum StateSpaceError {
+    /// The length of the provided bounds does not match the dimension.
+    DimensionMismatch { expected: usize, found: usize },
+    /// A lower bound is greater than or equal to its corresponding upper bound.
+    InvalidBound { lower: f64, upper: f64 },
+    /// A 0-dimensional space was requested without explicit (empty) bounds.
+    ZeroDimensionUnbounded,
+}
+impl fmt::Display for StateSpaceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::DimensionMismatch { expected, found } => write!(
+                f,
+                "provided bounds length ({found}) does not match specified dimension ({expected})."
+            ),
+            Self::InvalidBound { lower, upper } => {
+                write!(
+                    f,
+                    "Lower bound {lower} is greater than upper bound {upper}."
+                )
+            }
+            Self::ZeroDimensionUnbounded => {
+                write!(f, "Cannot create 0-dimensional unbounded space.")
+            }
+        }
+    }
+}
+impl error::Error for StateSpaceError {}
+
+#[derive(Debug, PartialEq)]
+pub enum StateSamplingError {
+    /// When trying to sample a space that isn't bounded.
+    UnboundedDimension { dimension_index: usize },
+    /// The space or region to be sampled has no volume (e.g., all dimensions have min >= max).
+    ZeroVolume,
+    /// It was not possible to generate a sample that satisfies the goal conditions.
+    GoalRegionUnsatisfiable,
+    /// An iterative sampling attempt (like for a goal region) failed to find a sample within a set number of attempts.
+    GoalSamplingTimeout { attempts: u32 },
+}
+impl fmt::Display for StateSamplingError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::UnboundedDimension { dimension_index } => {
+                write!(
+                    f,
+                    "Cannot sample uniformly because dimension {dimension_index} is unbounded."
+                )
+            }
+            Self::ZeroVolume => {
+                write!(f, "Cannot sample from a region with zero volume.")
+            }
+            Self::GoalRegionUnsatisfiable => {
+                write!(f, "Could not generate a sample from the goal region because its constraints may be unsatisfiable.")
+            }
+            Self::GoalSamplingTimeout { attempts } => {
+                write!(
+                    f,
+                    "Failed to generate a goal sample within {attempts} attempts."
+                )
+            }
+        }
+    }
+}
+impl error::Error for StateSamplingError {}
+
+#[derive(Debug, PartialEq)]
+pub enum PlanningError {
+    /// Solution search timed-out.
+    Timeout,
+    /// No solution found.
+    NoSolutionFound,
+}
+impl fmt::Display for PlanningError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Timeout => {
+                write!(f, "No solution found within timeout.")
+            }
+            Self::NoSolutionFound => {
+                write!(f, "No solution found.")
+            }
+        }
+    }
+}
+impl error::Error for PlanningError {}

oxmpl_py-0.1.0/oxmpl/src/base/goal.rs

@@ -0,0 +1,16 @@
+use crate::base::{error::StateSamplingError, state::State};
+use rand::Rng;
+
+pub trait Goal<S: State> {
+    fn is_satisfied(&self, state: &S) -> bool;
+}
+
+pub trait GoalRegion<S: State>: Goal<S> {
+    /// Returns the distance from a state to the goal region.
+    fn distance_goal(&self, state: &S) -> f64;
+}
+
+pub trait GoalSampleableRegion<S: State>: GoalRegion<S> {
+    /// Generates a state from the goal region.
+    fn sample_goal(&self, rng: &mut impl Rng) -> Result<S, StateSamplingError>;
+}

oxmpl_py-0.1.0/oxmpl/src/base/mod.rs

@@ -0,0 +1,9 @@
+mod spaces;
+
+pub mod error;
+pub mod goal;
+pub mod planner;
+pub mod problem_definition;
+pub mod space;
+pub mod state;
+pub mod validity;

oxmpl_py-0.1.0/oxmpl/src/base/planner.rs

@@ -0,0 +1,17 @@
+use crate::base::{
+    error::PlanningError, goal::Goal, problem_definition::ProblemDefinition, space::StateSpace,
+    state::State, validity::StateValidityChecker,
+};
+use std::{sync::Arc, time::Duration};
+
+#[derive(Clone)]
+pub struct Path<S: State>(pub Vec<S>);
+
+pub trait Planner<S: State, SP: StateSpace<StateType = S>, G: Goal<S>> {
+    fn setup(
+        &mut self,
+        problem_def: Arc<ProblemDefinition<S, SP, G>>,
+        validity_checker: Arc<dyn StateValidityChecker<S> + Send + Sync>,
+    );
+    fn solve(&mut self, timeout: Duration) -> Result<Path<S>, PlanningError>;
+}

oxmpl_py-0.1.0/oxmpl/src/base/problem_definition.rs

@@ -0,0 +1,9 @@
+use crate::base::{goal::Goal, space::StateSpace, state::State};
+use std::sync::Arc;
+
+pub struct ProblemDefinition<S: State, SP: StateSpace<StateType = S>, G: Goal<S>> {
+    pub space: Arc<SP>,
+    pub start_states: Vec<S>,
+    pub goal: Arc<G>,
+    // Potentially state_validity_checker here if not passed directly to planner
+}

oxmpl_py-0.1.0/oxmpl/src/base/space.rs

@@ -0,0 +1,38 @@
+use rand::Rng;
+
+use crate::base::{error::StateSamplingError, state::State};
+
+pub use crate::base::spaces::{
+    real_vector_state_space::RealVectorStateSpace,
+    so2_state_space::SO2StateSpace,
+};
+
+pub trait StateSpace {
+    /// StateType defines what is acceptable in current StateSpace
+    type StateType: State;
+    /// Find distance between current state1 and target state2. Depends on StateSpace.
+    fn distance(&self, state1: &Self::StateType, state2: &Self::StateType) -> f64;
+    /// Find state interpolated between `from` and `to` states given 0<=`t`<=1.
+    fn interpolate(
+        &self,
+        from: &Self::StateType,
+        to: &Self::StateType,
+        t: f64,
+        state: &mut Self::StateType,
+    );
+    /// Modifies the given state to ensure it conforms to the space's defined bounds.
+    fn enforce_bounds(&self, state: &mut Self::StateType);
+
+    fn satisfies_bounds(&self, state: &Self::StateType) -> bool;
+
+    /// Generates a state uniformly at random from the entire state space.
+    fn sample_uniform(&self, rng: &mut impl Rng) -> Result<Self::StateType, StateSamplingError>;
+}
+
+// #[cfg(test)]
+// #[path = "unittests/rvss_tests.rs"]
+// mod rvss_tests;
+
+// #[cfg(test)
+// #[path = "unittests/so2ss_tests.rs"]
+// mod so2ss_tests;

oxmpl_py-0.1.0/oxmpl/src/base/spaces/mod.rs

@@ -0,0 +1,2 @@
+pub mod real_vector_state_space;
+pub mod so2_state_space;

oxmpl_py-0.1.0/oxmpl/src/base/spaces/real_vector_state_space.rs

@@ -0,0 +1,150 @@
+use rand::Rng;
+
+use crate::base::{
+    error::{StateSamplingError, StateSpaceError}, space::StateSpace, state::RealVectorState
+};
+
+pub struct RealVectorStateSpace {
+    /// n-Dimensionality of VectorStateSpace i.e. R^n.
+    pub dimension: usize,
+    pub bounds: Vec<(f64, f64)>,
+}
+
+impl RealVectorStateSpace {
+    pub fn new(
+        dimension: usize,
+        bounds_option: Option<Vec<(f64, f64)>>,
+    ) -> Result<Self, StateSpaceError> {
+        let bounds = match bounds_option {
+            Some(explicit_bounds) => {
+                if explicit_bounds.len() != dimension {
+                    return Err(StateSpaceError::DimensionMismatch {
+                        expected: dimension,
+                        found: explicit_bounds.len(),
+                    });
+                }
+                for bound in &explicit_bounds {
+                    if bound.0 >= bound.1 {
+                        return Err(StateSpaceError::InvalidBound {
+                            lower: bound.0,
+                            upper: bound.1,
+                        });
+                    }
+                }
+                explicit_bounds
+            }
+            None => {
+                if dimension == 0 {
+                    return Err(StateSpaceError::ZeroDimensionUnbounded);
+                }
+                vec![(f64::NEG_INFINITY, f64::INFINITY); dimension]
+            }
+        };
+
+        Ok(Self { dimension, bounds })
+    }
+}
+
+impl StateSpace for RealVectorStateSpace {
+    type StateType = RealVectorState;
+
+    /// Find distance between current state1 and target state2. Depends on StateSpace.
+    /// In RealVectorStateSpace, this refers to the L2-norm.
+    fn distance(&self, state1: &Self::StateType, state2: &Self::StateType) -> f64 {
+        assert_eq!(
+            state1.values.len(),
+            self.dimension,
+            "State1 has incorrect dimension for this space."
+        );
+        assert_eq!(
+            state2.values.len(),
+            self.dimension,
+            "State2 has incorrect dimension for this space."
+        );
+        state1
+            .values
+            .iter()
+            .zip(state2.values.iter())
+            .map(|(v1, v2)| (v1 - v2).powi(2))
+            .sum::<f64>()
+            .sqrt()
+    }
+
+    fn interpolate(
+        &self,
+        from: &Self::StateType,
+        to: &Self::StateType,
+        t: f64,
+        out_state: &mut Self::StateType,
+    ) {
+        assert_eq!(
+            from.values.len(),
+            self.dimension,
+            "From-state has incorrect dimension."
+        );
+        assert_eq!(
+            to.values.len(),
+            self.dimension,
+            "To-state has incorrect dimension."
+        );
+        assert_eq!(
+            out_state.values.len(),
+            self.dimension,
+            "Out-state has incorrect dimension or not properly initialized."
+        );
+        for i in 0..from.values.len() {
+            out_state.values[i] = from.values[i] + (to.values[i] - from.values[i]) * t;
+        }
+    }
+
+    fn enforce_bounds(&self, state: &mut Self::StateType) {
+        if state.values.len() != self.dimension {
+            assert_eq!(
+                state.values.len(),
+                self.dimension,
+                "State and space dimension mismatch when enforcing bounds."
+            );
+        }
+        for (i, value) in state.values.iter_mut().enumerate() {
+            if i < self.bounds.len() {
+                let (lower, upper) = self.bounds[i];
+                *value = value.clamp(lower, upper);
+            }
+        }
+    }
+
+    fn satisfies_bounds(&self, state: &Self::StateType) -> bool {
+        if state.values.len() != self.dimension {
+            assert_eq!(
+                state.values.len(),
+                self.dimension,
+                "State and space dimension mismatch when checking bound satisfaction."
+            );
+        }
+        for i in 0..self.dimension {
+            let (lower, upper) = self.bounds[i];
+            if state.values[i] - f64::EPSILON > upper || state.values[i] + f64::EPSILON < lower {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn sample_uniform(&self, rng: &mut impl Rng) -> Result<Self::StateType, StateSamplingError> {
+        let mut values = Vec::with_capacity(self.dimension);
+
+        for i in 0..self.dimension {
+            let (lower, upper) = self.bounds[i];
+
+            if !lower.is_finite() || !upper.is_finite() {
+                return Err(StateSamplingError::UnboundedDimension { dimension_index: i });
+            }
+            if lower >= upper {
+                return Err(StateSamplingError::ZeroVolume);
+            }
+            values.push(rng.random_range(lower..upper));
+        }
+
+        Ok(RealVectorState { values })
+    }
+}

oxmpl_py-0.1.0/oxmpl/src/base/spaces/so2_state_space.rs

@@ -0,0 +1,48 @@
+use std::f64::consts::PI;
+use rand::Rng;
+
+use crate::base::{error::StateSamplingError, space::StateSpace, state::SO2State};
+
+pub struct SO2StateSpace {
+    // pub bounds: Vec<(f64, f64)>,
+}
+
+impl StateSpace for SO2StateSpace {
+    type StateType = SO2State;
+
+    fn distance(&self, state1: &Self::StateType, state2: &Self::StateType) -> f64 {
+        let mut diff = state1.value - state2.value;
+        diff = (diff + PI).rem_euclid(2.0 * PI) - PI;
+        diff.abs()
+    }
+
+    fn interpolate(
+        &self,
+        from: &Self::StateType,
+        to: &Self::StateType,
+        t: f64,
+        out_state: &mut Self::StateType,
+    ) {
+        let mut diff_to_from = to.clone().normalise().value - from.clone().normalise().value;
+        if diff_to_from > PI {
+            diff_to_from -= 2.0 * PI;
+        } else if diff_to_from < -PI {
+            diff_to_from += 2.0 * PI;
+        }
+        out_state.value = from.value + diff_to_from * t;
+        out_state.value = out_state.normalise().value;
+    }
+
+    // TODO
+    fn enforce_bounds(&self, _state: &mut Self::StateType) {}
+
+    // TODO
+    fn satisfies_bounds(&self, _state: &Self::StateType) -> bool {
+        false
+    }
+
+    fn sample_uniform(&self, rng: &mut impl Rng) -> Result<SO2State, StateSamplingError> {
+        todo!()
+    }
+}
+

oxmpl_py-0.1.0/oxmpl/src/base/state.rs

@@ -0,0 +1,70 @@
+use std::f64::consts::PI;
+
+pub trait State: Clone + Send + Sync + 'static {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RealVectorState {
+    pub values: Vec<f64>,
+}
+impl State for RealVectorState {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct SO2State {
+    pub value: f64,
+}
+impl SO2State {
+    pub fn new(val: f64) -> Self {
+        SO2State {
+            value: (val + PI).rem_euclid(2.0 * PI) - PI,
+        }
+    }
+
+    pub fn normalise(&mut self) -> Self {
+        SO2State {
+            value: (self.value + PI).rem_euclid(2.0 * PI) - PI,
+        }
+    }
+}
+impl State for SO2State {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_real_vector_state_creation() {
+        let state = RealVectorState {
+            values: vec![1.0, 2.0],
+        };
+        assert_eq!(state.values, vec![1.0, 2.0]);
+    }
+
+    #[test]
+    fn test_real_vector_state_clone() {
+        let state1 = RealVectorState {
+            values: vec![1.0, 2.0],
+        };
+        let state2 = state1.clone();
+        assert_eq!(state1, state2);
+    }
+
+    #[test]
+    fn test_so2_state_creation() {
+        let state = SO2State { value: 1.0 };
+        assert_eq!(state.value, 1.0);
+    }
+
+    #[test]
+    fn test_so2_state_clone() {
+        let state1 = SO2State { value: 1.0 };
+        let state2 = state1.clone();
+        assert_eq!(state1, state2);
+    }
+
+    #[test]
+    fn test_so2_state_normalise() {
+        let mut state1 = SO2State { value: 3.0 * PI / 2.0 };
+        let state2 = state1.normalise();
+        assert_eq!(state2.value, -PI / 2.0);
+    }
+}