Added parameters

src/lib.rs

@@ -9,24 +9,57 @@ pub mod problem;
 
 #[cfg(test)]
 mod tests {
-    use nalgebra::Vector6;
+    use nalgebra::{Vector3, Vector6};
     use approx::assert_relative_eq;
     use crate::integrator::dormand_prince::DormandPrince45;
     use crate::controller::PIController;
+    use crate::callback::{Callback, stop};
     use crate::ode::ODE;
     use crate::problem::Problem;
     use std::f64::consts::PI;
 
     #[test]
-    fn test_orbit() {
+    fn test_readme() {
+        // Define the system (parameters, derivative, and initial state)
+        type Params = (f64, bool);
+        let params = (34.0, true);
 
+        fn derivative(t: f64, y: Vector3<f64>, p: &Params) -> Vector3<f64> {
+          if p.1 { -y } else { y * t }
+        }
+
+        let y0 = Vector3::new(1.0, 1.0, 1.0);
+
+        // Set up the problem (ODE, Integrator, Controller, and Callbacks)
+        let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
+        let dp45 = DormandPrince45::new(1e-12_f64, 1e-5_f64);
+        let controller = PIController::default();
+
+        let value_too_high = Callback {
+            event: &|_: f64, y: Vector3<f64>, _: &Params| { 10.0 - y[0] },
+            effect: &stop,
+        };
+
+        // Solve the problem
+        let mut problem = Problem::new(ode, dp45, controller).with_callback(value_too_high);
+        let solution = problem.solve();
+
+        // Can interpolate solutions to whatever you want
+        let _interpolated_answer = solution.interpolate(8.2);
+    }
+
+    #[test]
+    fn test_orbit() {
         // Calculate one period
         let a = 6.7781363e6_f64;
-        let period = 2.0 * PI * (a.powi(3)/3.98600441500000e14).sqrt();
+        let mu = 3.98600441500000e14;
+        let period = 2.0 * PI * (a.powi(3)/mu).sqrt();
 
         // Set up the system
-        fn derivative(_t: f64, state: Vector6<f64>) -> Vector6<f64> {
-            let acc = -(3.98600441500000e14 * state.fixed_rows::<3>(0)) / (state.fixed_rows::<3>(0).norm().powi(3));
+        type Params = (f64,);
+        let params = (mu,);
+        fn derivative(_t: f64, state: Vector6<f64>, p: &Params) -> Vector6<f64> {
+            let acc = -(p.0 * state.fixed_rows::<3>(0)) / (state.fixed_rows::<3>(0).norm().powi(3));
             Vector6::new(state[3], state[4], state[5], acc[0], acc[1], acc[2])
         }
         let y0 = Vector6::new(
@@ -39,7 +72,7 @@ mod tests {
         );
 
         // Integrate
-        let ode = ODE::new(&derivative, 0.0, 10.0*period, y0);
+        let ode = ODE::new(&derivative, 0.0, 10.0*period, y0, params);
         let dp45 = DormandPrince45::new(1e-12_f64, 1e-12_f64);
         let controller = PIController::new(0.37, 0.04, 10.0, 0.2, 1000.0, 0.9, 0.01);