found and solved the bug in the tests

ZocoLini · ZocoLini · commit fbc511ff740f · 2025-05-26T16:30:51.000+02:00
diff --git a/deps.cmake b/deps.cmake
@@ -82,6 +82,7 @@ set(RUST_LIB_DIR "${PROJECT_SOURCE_DIR}/modules/mexpreval")
 set(RUST_TARGET_DIR "${RUST_LIB_DIR}/target/release")
 
 add_custom_target(rust_lib ALL
+    env RUSTFLAGS=-C target-cpu=native
     COMMAND cargo build --release
     WORKING_DIRECTORY ${RUST_LIB_DIR}
 )
diff --git a/modules/mexpreval/benches/eval_f_exprs_bench.rs b/modules/mexpreval/benches/eval_f_exprs_bench.rs
@@ -12,8 +12,8 @@ fn lotka_volterra_bench_eval(c: &mut Criterion) {
     let mut params = vec![0.1, 0.2, 0.3, 0.4];
 
     let expr_strings = [
-        CString::new("p1 * y1 - p2 * y2").unwrap(),
-        CString::new("p3 * y2 - p4 * y1").unwrap(),
+        CString::new("y1 * (p1 - p2 * y2)").unwrap(),
+        CString::new("-y2 * (p3 - p4 * y1)").unwrap(),
     ];
     let expr_ptrs: Vec<*const c_char> = expr_strings.iter().map(|s| s.as_ptr()).collect();
     
@@ -31,6 +31,7 @@ fn lotka_volterra_bench_eval(c: &mut Criterion) {
     });
 }
 
+#[allow(dead_code)]
 fn lotka_volterra_predefined_bench_eval(c: &mut Criterion) {
     let num_exprs = 2;
     let num_params = 4;
@@ -62,9 +63,9 @@ fn logistic_model_bench_eval(c: &mut Criterion) {
     let num_exprs = 1;
     let num_params = 2;
 
-    let mut y = vec![1.0];
+    let mut y = vec![0.0];
     let mut ydot = vec![0.0; num_exprs];
-    let mut params = vec![0.1, 0.2];
+    let mut params = vec![0.1, 100.0];
 
     let expr_strings = [
         CString::new("p1 * y1 * (1 - y1 / p2)").unwrap()
@@ -116,5 +117,5 @@ fn alpha_pinene_bench_eval(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, lotka_volterra_bench_eval, logistic_model_bench_eval, alpha_pinene_bench_eval, lotka_volterra_predefined_bench_eval);
+criterion_group!(benches, lotka_volterra_bench_eval, logistic_model_bench_eval, alpha_pinene_bench_eval);
 criterion_main!(benches);
diff --git a/modules/mexpreval/src/lib.rs b/modules/mexpreval/src/lib.rs
@@ -1,8 +1,8 @@
 #![allow(static_mut_refs)]
+#![allow(invalid_reference_casting)]
 mod models;
 
-use meval::{Context, Expr};
-use std::cell::OnceCell;
+use meval::{Context, ContextProvider, Expr};
 use std::str::FromStr;
 use std::sync::LazyLock;
 use std::{env, ffi::CStr, os::raw::c_char, slice};
@@ -36,10 +36,10 @@ impl OdeExpr {
 }
 
 static mut EXPRS: Vec<Expr> = Vec::new();
-static mut CONTEXT: OnceCell<Context<'static>> = OnceCell::new();
+static mut CONTEXT: Option<Context<'static>> = None;
 static mut Y: Vec<String> = Vec::new();
 static mut P: Vec<String> = Vec::new();
-static mut ODE_EXPR: OnceCell<OdeExpr> = OnceCell::new();
+static mut ODE_EXPR: Option<OdeExpr> = None;
 static DEF_YDOT: LazyLock<f64> = LazyLock::new(|| {
     env::var("CUQDYN_DEF_YDOT")
         .unwrap_or_else(|_| "0.0".to_string())
@@ -50,11 +50,13 @@ static DEF_YDOT: LazyLock<f64> = LazyLock::new(|| {
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]
 pub unsafe extern "C" fn mexpreval_init(ode_expr: OdeExpr) {
+    Y.clear();
     Y.extend(
         (0..ode_expr.y_count)
             .map(|i| format!("y{}", i + 1))
             .collect::<Vec<String>>(),
     );
+    P.clear();
     P.extend(
         (0..ode_expr.p_count)
             .map(|i| format!("p{}", i + 1))
@@ -63,6 +65,7 @@ pub unsafe extern "C" fn mexpreval_init(ode_expr: OdeExpr) {
 
     let exprs: &[*const c_char] = slice::from_raw_parts(ode_expr.exprs, ode_expr.y_count as usize);
 
+    EXPRS.clear();
     for ptr in exprs.iter() {
         let c_str = CStr::from_ptr(*ptr);
         let s = c_str.to_str().unwrap();
@@ -71,15 +74,15 @@ pub unsafe extern "C" fn mexpreval_init(ode_expr: OdeExpr) {
 
         EXPRS.push(expr);
     }
-
-    let _ = CONTEXT.set(Context::new());
-    let _ = ODE_EXPR.set(ode_expr);
+    
+    CONTEXT = Some(Context::new());
+    ODE_EXPR = Some(ode_expr);
 }
 
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]
 pub unsafe extern "C" fn eval_f_exprs(_t: f64, y: *mut f64, ydot: *mut f64, params: *mut f64) {
-    let ctx = CONTEXT.get_mut().unwrap_unchecked();
+    let ctx = CONTEXT.as_mut().unwrap();
 
     let y: &[f64] = slice::from_raw_parts(y, Y.len());
     let ydot: &mut [f64] = slice::from_raw_parts_mut(ydot, Y.len());
@@ -94,9 +97,8 @@ pub unsafe extern "C" fn eval_f_exprs(_t: f64, y: *mut f64, ydot: *mut f64, para
     }
 
     for (i, expr) in EXPRS.iter().enumerate() {
-        ydot[i] = expr
-            .eval_with_context(CONTEXT.get().unwrap_unchecked())
-            .unwrap_unchecked();
+        let ctx = CONTEXT.as_ref().unwrap();
+        ydot[i] = expr.eval_with_context(ctx).unwrap();
 
         if !ydot[i].is_finite() {
             eprintln!(
@@ -117,6 +119,59 @@ mod test {
     use std::ffi::CString;
     use std::os::raw::c_char;
 
+    #[test]
+    fn lotka_volterra_test() {
+        let num_exprs = 2;
+        let num_params = 4;
+
+        let mut y = vec![1.0, 1.0];
+        let mut ydot = vec![0.0; num_exprs];
+        let mut params = vec![1.0, 2.0, 3.0, 4.0];
+
+        let expr_strings = [
+            CString::new("y1 * (p1 - p2 * y2)").unwrap(),
+            CString::new("-y2 * (p3 - p4 * y1)").unwrap(),
+        ];
+        let expr_ptrs: Vec<*const c_char> = expr_strings.iter().map(|s| s.as_ptr()).collect();
+
+        unsafe {
+            mexpreval_init(OdeExpr::new(
+                num_exprs as i32,
+                num_params,
+                expr_ptrs.as_ptr(),
+            ));
+        }
+
+        unsafe { eval_f_exprs(0.0, y.as_mut_ptr(), ydot.as_mut_ptr(), params.as_mut_ptr()) }
+
+        assert_eq!(ydot[0], -1.0);
+        assert_eq!(ydot[1], 1.0);
+    }
+
+    #[test]
+    fn logistic_model_test() {
+        let num_exprs = 1;
+        let num_params = 2;
+
+        let mut y = vec![1.0];
+        let mut ydot = vec![0.0; num_exprs];
+        let mut params = vec![0.1, 100.0];
+
+        let expr_strings = [CString::new("p1 * y1 * (1 - y1 / p2)").unwrap()];
+        let expr_ptrs: Vec<*const c_char> = expr_strings.iter().map(|s| s.as_ptr()).collect();
+
+        unsafe {
+            mexpreval_init(OdeExpr::new(
+                num_exprs as i32,
+                num_params,
+                expr_ptrs.as_ptr(),
+            ));
+        }
+
+        unsafe { eval_f_exprs(0.0, y.as_mut_ptr(), ydot.as_mut_ptr(), params.as_mut_ptr()) }
+        assert_eq!(ydot[0], 0.99)
+    }
+
     #[test]
     fn bench() {
         let num_exprs = 1;
diff --git a/tests/test_ess_solver.c b/tests/test_ess_solver.c
@@ -23,15 +23,9 @@ int main(int argc, char **argv)
     return 0;
 #endif
 
-    logistic_model_ess(LOGISTIC_MODEL_CONF_FILE_NL2SOL_DN2FB);
-    printf("\tTest 5 passed Logistic Model NL2SOL_DN2FB\n");
-
     lotka_volterra_ess(LOTKA_VOLTERRA_CONF_FILE_NL2SOL_DN2GB);
     printf("\tTest 1 passed NL2SOL_DN2GB\n");
 
-    alpha_pinene_ess(ALPHA_PINENE_CONF_FILE_NL2SOL_DN2FB);
-    printf("\tTest 6 passed Alpha-Pinene NL2SOL_DN2GB\n");
-
     lotka_volterra_ess(LOTKA_VOLTERRA_CONF_FILE_NL2SOL_DN2FB);
     printf("\tTest 2 passed NL2SOL_DN2FB\n");
 
@@ -41,6 +35,12 @@ int main(int argc, char **argv)
     lotka_volterra_ess(LOTKA_VOLTERRA_CONF_FILE_MISQP);
     printf("\tTest 4 passed MISQP\n");
 
+    logistic_model_ess(LOGISTIC_MODEL_CONF_FILE_NL2SOL_DN2FB);
+    printf("\tTest 5 passed Logistic Model NL2SOL_DN2FB\n");
+
+    alpha_pinene_ess(ALPHA_PINENE_CONF_FILE_NL2SOL_DN2FB);
+    printf("\tTest 6 passed Alpha-Pinene NL2SOL_DN2GB\n");
+    
     return 0;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ set(RUST_LIB_DIR "${PROJECT_SOURCE_DIR}/modules/mexpreval")`
`82`	`82`	`set(RUST_TARGET_DIR "${RUST_LIB_DIR}/target/release")`
`83`	`83`
`84`	`84`	`add_custom_target(rust_lib ALL`
	`85`	`+ env RUSTFLAGS=-C target-cpu=native`
`85`	`86`	`COMMAND cargo build --release`
`86`	`87`	`WORKING_DIRECTORY ${RUST_LIB_DIR}`
`87`	`88`	`)`