fix: build pred-prey fit example, fix compile errors (#225)

* fix: build pred-prey fit example, fix compile errors

* fix in statements in diffsl code

Author: martinjrobins

book/src/primer/src/spm.ds

@@ -1,6 +1,5 @@
-in = [currentfunctiona]
-currentfunctiona {
-  1
+in { 
+  currentfunctiona = 1
 }
 constant0_i {
   (0:19): 0.0,

diffsol/benches/pybamm_dfn.diffsl

@@ -1,4 +1,3 @@
-in = []
 constant0_i {
   (0:1): 0.00018906,
 }

diffsol/src/ode_equations/test_models/foodweb.rs

@@ -69,7 +69,6 @@ where
 
     let code = format!(
         "
-        in = []
         AA {{ 1.0 }}
         EE {{ 10000.0 }}
         GG {{ 0.5e-6 }}

diffsol/src/ode_equations/test_models/heat2d.rs

@@ -58,7 +58,6 @@ pub fn heat2d_diffsl_problem<
 
     let code = format!(
         "
-        in = []
         D_ij {{
 {}
         }}

examples/intro-logistic-diffsl/src/main.rs

@@ -9,9 +9,7 @@ fn main() {
         .p([1.0, 10.0])
         .build_from_diffsl::<CG>(
             "
-                in = [r, k]
-                r { 1.0 }
-                k { 1.0 }
+                in_i { r = 1.0, k = 1.0 }
                 u { 0.1 }
                 F { r * u * (1.0 - u / k) }
             ",

examples/mass-spring-fitting-adjoint/src/main_llvm.rs

@@ -93,8 +93,8 @@ pub fn main() {
         .out_rtol(1e-6)
         .build_from_diffsl(
             "
-        in = [k, c]
-        k { 1.0 } m { 1.0 } c { 0.1 }
+        in_i { k = 1.0, c = 0.1 }
+        m { 1.0 }
         u_i {
             x = 1,
             v = 0,

examples/population-dynamics/src/main.rs

@@ -61,8 +61,7 @@ fn phase_plane() {
         .p([1.0])
         .build_from_diffsl::<CG>(
             "
-        in = [ y0 ]
-        y0 { 1.0 }
+        in { y0 = 1.0 }
         a { 2.0/3.0 } b { 4.0/3.0 } c { 1.0 } d { 1.0 }
         u_i {
             y1 = y0,

examples/predator-prey-fitting-forward/Cargo.toml

@@ -5,10 +5,10 @@ edition.workspace = true
 publish = false
 
 [features]
-diffsl-llvm15 = ["diffsol/diffsl-llvm15"]
-diffsl-llvm16 = ["diffsol/diffsl-llvm16"]
-diffsl-llvm17 = ["diffsol/diffsl-llvm17"]
-diffsl-llvm18 = ["diffsol/diffsl-llvm18"]
+diffsl-llvm15 = ["diffsol/diffsl-llvm15", "diffsl-llvm"]
+diffsl-llvm16 = ["diffsol/diffsl-llvm16", "diffsl-llvm"]
+diffsl-llvm17 = ["diffsol/diffsl-llvm17", "diffsl-llvm"]
+diffsl-llvm18 = ["diffsol/diffsl-llvm18", "diffsl-llvm"]
 diffsl-llvm = []
 
 [dependencies]

examples/predator-prey-fitting-forward/src/main_llvm.rs

@@ -4,14 +4,13 @@ use argmin::{
 };
 use argmin_observer_slog::SlogLogger;
 use diffsol::{
-    DiffSl, OdeBuilder, OdeEquations, OdeSolverMethod, OdeSolverProblem,
-    SensitivitiesOdeSolverMethod,
+    DiffSl, MatrixCommon, OdeBuilder, OdeEquations, OdeSolverMethod, OdeSolverProblem, Op,
+    SensitivitiesOdeSolverMethod, Vector,
 };
-use nalgebra::{DMatrix, DVector};
 use std::cell::RefCell;
 
-type M = DMatrix<f64>;
-type V = DVector<f64>;
+type M = diffsol::NalgebraMat<f64>;
+type V = diffsol::NalgebraVec<f64>;
 type T = f64;
 type LS = diffsol::NalgebraLU<f64>;
 type CG = diffsol::LlvmModule;
@@ -29,15 +28,19 @@ impl CostFunction for Problem {
 
     fn cost(&self, param: &Self::Param) -> Result<Self::Output, argmin_math::Error> {
         let mut problem = self.problem.borrow_mut();
-        problem.eqn_mut().set_params(&V::from_vec(param.clone()));
+        let ctx = *problem.eqn().context();
+        problem
+            .eqn_mut()
+            .set_params(&V::from_vec(param.clone(), ctx));
         let mut solver = problem.bdf::<LS>().unwrap();
         let ys = match solver.solve_dense(&self.ts_data) {
             Ok(ys) => ys,
             Err(_) => return Ok(f64::MAX / 1000.),
         };
         let loss = ys
+            .inner()
             .column_iter()
-            .zip(self.ys_data.column_iter())
+            .zip(self.ys_data.inner().column_iter())
             .map(|(a, b)| (a - b).norm_squared())
             .sum::<f64>();
         Ok(loss)
@@ -50,7 +53,10 @@ impl Gradient for Problem {
 
     fn gradient(&self, param: &Self::Param) -> Result<Self::Gradient, argmin_math::Error> {
         let mut problem = self.problem.borrow_mut();
-        problem.eqn_mut().set_params(&V::from_vec(param.clone()));
+        let ctx = *problem.eqn().context();
+        problem
+            .eqn_mut()
+            .set_params(&V::from_vec(param.clone(), ctx));
         let mut solver = problem.bdf_sens::<LS>().unwrap();
         let (ys, sens) = match solver.solve_dense_sensitivities(&self.ts_data) {
             Ok((ys, sens)) => (ys, sens),
@@ -59,8 +65,13 @@ impl Gradient for Problem {
         let dlossdp = sens
             .into_iter()
             .map(|s| {
-                s.column_iter()
-                    .zip(ys.column_iter().zip(self.ys_data.column_iter()))
+                s.inner()
+                    .column_iter()
+                    .zip(
+                        ys.inner()
+                            .column_iter()
+                            .zip(self.ys_data.inner().column_iter()),
+                    )
                     .map(|(si, (yi, di))| 2.0 * (yi - di).dot(&si))
                     .sum::<f64>()
             })
@@ -70,10 +81,9 @@ impl Gradient for Problem {
 }
 
 pub fn main() {
-    let eqn = DiffSl::<M, CG>::compile(
-        "
-            in = [ b, d ]
-            a { 2.0/3.0 } b { 4.0/3.0 } c { 1.0 } d { 1.0 } x0 { 1.0 } y0 { 1.0 }
+    let code = "
+            in_i { b = 4.0/3.0, d = 1.0 }
+            a { 2.0/3.0 } c { 1.0 } x0 { 1.0 } y0 { 1.0 }
             u_i {
                 y1 = x0,
                 y2 = y0,
@@ -82,9 +92,7 @@ pub fn main() {
                 a * y1 - b * y1 * y2,
                 c * y1 * y2 - d * y2,
             }
-        ",
-    )
-    .unwrap();
+        ";
 
     let (b_true, d_true) = (4.0 / 3.0, 1.0);
     let t_data = (0..101)
@@ -94,10 +102,12 @@ pub fn main() {
         .p([b_true, d_true])
         .sens_atol([1e-6])
         .sens_rtol(1e-6)
-        .build_from_eqn(eqn)
+        .build_from_diffsl(code)
         .unwrap();
-    let mut solver = problem.bdf::<LS>().unwrap();
-    let ys_data = solver.solve_dense(&t_data).unwrap();
+    let ys_data = {
+        let mut solver = problem.bdf::<LS>().unwrap();
+        solver.solve_dense(&t_data).unwrap()
+    };
 
     let cost = Problem {
         ys_data,

examples/python-diffsol/test/test_solve.py

@@ -7,8 +7,7 @@ class TestStringMethods(unittest.TestCase):
     def test_solve(self):
         model = PyDiffsol(
             """
-            in = [r, k]
-            r { 1 } k { 1 }
+            in_i { r = 1, k = 1 }
             u_i { y = 0.1 }
             F_i { (r * y) * (1 - (y / k)) }
             """