feat: Deprecate fixed but unknown

benches/bimodal_ke.rs

@@ -21,8 +21,8 @@ fn create_equation() -> equation::ODE {
 
 fn setup_simulation() -> Result<(Settings, equation::ODE, data::Data)> {
     let params = Parameters::new()
-        .add("ke", 0.001, 3.0, false)
-        .add("v", 25.0, 250.0, false);
+        .add("ke", 0.001, 3.0)
+        .add("v", 25.0, 250.0);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/bimodal_ke/main.rs

@@ -19,8 +19,8 @@ fn main() -> Result<()> {
     );
 
     let params = Parameters::new()
-        .add("ke", 0.001, 3.0, false)
-        .add("v", 25.0, 250.0, false);
+        .add("ke", 0.001, 3.0)
+        .add("v", 25.0, 250.0);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/drusano/main.rs

@@ -81,30 +81,30 @@ fn main() -> Result<()> {
     );
 
     let params = Parameters::new()
-        .add("v1", 5.0, 160.0, false)
-        .add("cl1", 4.0, 9.0, false)
-        .add("v2", 100.0, 200.0, false)
-        .add("cl2", 25.0, 35.0, false)
-        .add("popmax", 100000000.0, 100000000000.0, false)
-        .add("kgs", 0.01, 0.25, false)
-        .add("kks", 0.01, 0.5, false)
-        .add("e50_1s", 0.1, 2.5, false)
-        .add("e50_2s", 0.1, 10.0, false)
-        .add("alpha_s", -8.0, 5.0, false)
-        .add("kgr1", 0.004, 0.1, false)
-        .add("kkr1", 0.08, 0.4, false)
-        .add("e50_1r1", 8.0, 17.0, false)
-        .add("alpha_r1", -8.0, 5.0, false)
-        .add("kgr2", 0.004, 0.3, false)
-        .add("kkr2", 0.1, 0.5, false)
-        .add("e50_2r2", 5.0, 8.0, false)
-        .add("alpha_r2", -5.0, 5.0, false)
-        .add("init_4", -1.0, 4.0, false)
-        .add("init_5", -1.0, 3.0, false)
-        .add("h1s", 0.5, 8.0, false)
-        .add("h2s", 0.1, 4.0, false)
-        .add("h1r1", 5.0, 25.0, false)
-        .add("h2r2", 10.0, 22.0, false);
+        .add("v1", 5.0, 160.0)
+        .add("cl1", 4.0, 9.0)
+        .add("v2", 100.0, 200.0)
+        .add("cl2", 25.0, 35.0)
+        .add("popmax", 100000000.0, 100000000000.0)
+        .add("kgs", 0.01, 0.25)
+        .add("kks", 0.01, 0.5)
+        .add("e50_1s", 0.1, 2.5)
+        .add("e50_2s", 0.1, 10.0)
+        .add("alpha_s", -8.0, 5.0)
+        .add("kgr1", 0.004, 0.1)
+        .add("kkr1", 0.08, 0.4)
+        .add("e50_1r1", 8.0, 17.0)
+        .add("alpha_r1", -8.0, 5.0)
+        .add("kgr2", 0.004, 0.3)
+        .add("kkr2", 0.1, 0.5)
+        .add("e50_2r2", 5.0, 8.0)
+        .add("alpha_r2", -5.0, 5.0)
+        .add("init_4", -1.0, 4.0)
+        .add("init_5", -1.0, 3.0)
+        .add("h1s", 0.5, 8.0)
+        .add("h2s", 0.1, 4.0)
+        .add("h1r1", 5.0, 25.0)
+        .add("h2r2", 10.0, 22.0);
 
     let mut settings = SettingsBuilder::new()
         .set_algorithm(Algorithm::NPAG)

examples/iov/main.rs

@@ -29,7 +29,7 @@ fn main() -> Result<()> {
         10000,
     );
 
-    let params = Parameters::new().add("ke0", 0.001, 2.0, false);
+    let params = Parameters::new().add("ke0", 0.001, 2.0);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/meta/main.rs

@@ -33,13 +33,13 @@ fn main() {
     );
 
     let params = Parameters::new()
-        .add("cls", 0.1, 10.0, true)
-        .add("fm", 0.0, 1.0, true)
-        .add("k20", 0.01, 1.0, true)
-        .add("relv", 0.1, 1.0, true)
-        .add("theta1", 0.1, 10.0, true)
-        .add("theta2", 0.1, 10.0, true)
-        .add("vs", 1.0, 10.0, true);
+        .add("cls", 0.1, 10.0)
+        .add("fm", 0.0, 1.0)
+        .add("k20", 0.01, 1.0)
+        .add("relv", 0.1, 1.0)
+        .add("theta1", 0.1, 10.0)
+        .add("theta2", 0.1, 10.0)
+        .add("vs", 1.0, 10.0);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/new_iov/main.rs

@@ -30,8 +30,8 @@ fn main() {
     );
 
     let params = Parameters::new()
-        .add("ke0", 0.0001, 2.4, false)
-        .add("ske", 0.0001, 0.2, false);
+        .add("ke0", 0.0001, 2.4)
+        .add("ske", 0.0001, 0.2);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/theophylline/main.rs

@@ -31,9 +31,9 @@ fn main() {
     );
 
     let params = Parameters::new()
-        .add("ka", 0.001, 3.0, false)
-        .add("ke", 0.001, 3.0, false)
-        .add("v", 0.001, 50.0, false);
+        .add("ka", 0.001, 3.0)
+        .add("ke", 0.001, 3.0)
+        .add("v", 0.001, 50.0);
 
     let settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/two_eq_lag/main.rs

@@ -68,10 +68,10 @@ fn main() {
     // );
 
     let params = Parameters::new()
-        .add("ka", 0.1, 0.9, false)
-        .add("ke", 0.001, 0.1, false)
-        .add("tlag", 0.0, 4.0, false)
-        .add("v", 30.0, 120.0, false);
+        .add("ka", 0.1, 0.9)
+        .add("ke", 0.001, 0.1)
+        .add("tlag", 0.0, 4.0)
+        .add("v", 30.0, 120.0);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

examples/vanco_sde/main.rs

@@ -49,12 +49,12 @@ fn main() {
     // );
 
     let params = Parameters::new()
-        .add("ka", 0.0001, 2.4, false)
-        .add("ke0", 0.0001, 2.7, false)
-        .add("kcp", 0.0001, 2.4, false)
-        .add("kpc", 0.0001, 2.4, false)
-        .add("vol", 0.2, 12.0, false)
-        .add("ske", 0.0001, 0.2, false);
+        .add("ka", 0.0001, 2.4)
+        .add("ke0", 0.0001, 2.7)
+        .add("kcp", 0.0001, 2.4)
+        .add("kpc", 0.0001, 2.4)
+        .add("vol", 0.2, 12.0)
+        .add("ske", 0.0001, 0.2);
 
     let mut settings = Settings::builder()
         .set_algorithm(Algorithm::NPAG)

src/algorithms/mod.rs

@@ -261,6 +261,7 @@ pub trait Algorithms<E: Equation>: Sync {
         Ok(self.into_npresult())
     }
 
+    #[allow(clippy::wrong_self_convention)]
     fn into_npresult(&self) -> NPResult<E>;
 }
 

src/algorithms/npod.rs

@@ -37,7 +37,6 @@ const THETA_D: f64 = 1e-4;
 
 pub struct NPOD<E: Equation> {
     equation: E,
-    ranges: Vec<(f64, f64)>,
     psi: Psi,
     theta: Theta,
     lambda: Col<f64>,
@@ -57,7 +56,6 @@ impl<E: Equation> Algorithms<E> for NPOD<E> {
     fn new(settings: Settings, equation: E, data: Data) -> Result<Box<Self>, anyhow::Error> {
         Ok(Box::new(Self {
             equation,
-            ranges: settings.parameters().ranges(),
             psi: Psi::new(),
             theta: Theta::new(),
             lambda: Col::zeros(0),
@@ -360,8 +358,7 @@ impl<E: Equation> Algorithms<E> for NPOD<E> {
             // re-define a new optimization
         });
         for cp in candididate_points {
-            self.theta
-                .suggest_point(cp.to_vec().as_slice(), THETA_D, &self.ranges);
+            self.theta.suggest_point(cp.to_vec().as_slice(), THETA_D);
         }
         Ok(())
     }

src/routines/expansion/adaptative_grid.rs

@@ -44,7 +44,7 @@ pub fn adaptative_grid(theta: &mut Theta, eps: f64, ranges: &[(f64, f64)], min_d
     // Option 1: Check all points against the original theta, then add them
     let keep = candidates
         .iter()
-        .filter(|point| theta.check_point(point, min_dist, ranges))
+        .filter(|point| theta.check_point(point, min_dist))
         .cloned()
         .collect::<Vec<_>>();
 

src/routines/initialization/latin.rs

@@ -20,48 +20,79 @@ use crate::structs::theta::Theta;
 /// [Theta], a structure that holds the support point matrix
 ///
 pub fn generate(parameters: &Parameters, points: usize, seed: usize) -> Result<Theta> {
-    let params: Vec<(String, f64, f64, bool)> = parameters
+    let params: Vec<(String, f64, f64)> = parameters
         .iter()
-        .map(|p| (p.name.clone(), p.lower, p.upper, p.fixed))
-        .collect();
-
-    // Random parameters are sampled from the Sobol sequence
-    let random_params: Vec<(String, f64, f64)> = params
-        .iter()
-        .filter(|(_, _, _, fixed)| !fixed)
-        .map(|(name, lower, upper, _)| (name.clone(), *lower, *upper))
+        .map(|p| (p.name.clone(), p.lower, p.upper))
         .collect();
 
     // Initialize random number generator with the provided seed
     let mut rng = StdRng::seed_from_u64(seed as u64);
 
     // Create and shuffle intervals for each parameter
     let mut intervals = Vec::new();
-    for _ in 0..random_params.len() {
+    for _ in 0..params.len() {
         let mut param_intervals: Vec<f64> = (0..points).map(|i| i as f64).collect();
         param_intervals.shuffle(&mut rng);
         intervals.push(param_intervals);
     }
 
-    let rand_matrix = Mat::from_fn(points, random_params.len(), |i, j| {
+    let rand_matrix = Mat::from_fn(points, params.len(), |i, j| {
         // Get the interval for this parameter and point
         let interval = intervals[j][i];
         let random_offset = rng.random::<f64>();
         // Calculate normalized value in [0,1]
         let unscaled = (interval + random_offset) / points as f64;
         // Scale to parameter range
-        let (_name, lower, upper) = random_params.get(j).unwrap(); // Fixed: use j instead of i
+        let (_name, lower, upper) = params.get(j).unwrap(); // Fixed: use j instead of i
         lower + unscaled * (upper - lower)
     });
 
-    // Fixed parameters are initialized to the middle of their range
-    let fixed_params: Vec<(String, f64)> = params
-        .iter()
-        .filter(|(_, _, _, fixed)| *fixed)
-        .map(|(name, lower, upper, _)| (name.clone(), (upper - lower) / 2.0))
-        .collect();
-
-    let theta = Theta::from_parts(rand_matrix, random_params, fixed_params);
+    let theta = Theta::from_parts(rand_matrix, parameters.clone());
 
     Ok(theta)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::prelude::Parameters;
+    use faer::mat;
+
+    #[test]
+    fn test_latin_hypercube() {
+        let params = Parameters::new()
+            .add("a", 0.0, 1.0)
+            .add("b", 0.0, 1.0)
+            .add("c", 0.0, 1.0);
+
+        let theta = generate(&params, 10, 22).unwrap();
+
+        assert_eq!(theta.nspp(), 10);
+        assert_eq!(theta.matrix().ncols(), 3);
+    }
+
+    #[test]
+    fn test_latin_hypercube_values() {
+        let params = Parameters::new()
+            .add("a", 0.0, 1.0)
+            .add("b", 0.0, 1.0)
+            .add("c", 0.0, 1.0);
+
+        let theta = generate(&params, 10, 22).unwrap();
+
+        let expected = mat![
+            [0.9318592685623417, 0.5609665425179973, 0.3351914901515939], //
+            [0.5470144220416706, 0.13513808559222779, 0.1067962439473777], //
+            [0.34525902829190547, 0.4636722699673962, 0.9142146621998218], //
+            [0.24828355387285125, 0.8638104433695395, 0.41653980640777954], //
+            [0.7642037770085612, 0.6806932027789437, 0.5608053599272136], //
+            [0.19409389824004936, 0.9378790633419902, 0.6039530631991072], //
+            [0.04886813284275151, 0.7140428162864041, 0.7855069414226704], //
+            [0.6987026842780971, 0.32378779989236495, 0.8888807957183007], //
+            [0.4221279608793599, 0.08001464382386277, 0.20689573661666943], //
+            [0.8310112718320113, 0.29390050406905127, 0.04806137233953963], //
+        ];
+
+        assert_eq!(theta.matrix().to_owned(), expected);
+    }
+}

src/routines/initialization/mod.rs

@@ -139,16 +139,7 @@ pub fn parse_prior(path: &String, settings: &Settings) -> Result<Theta> {
     let theta_matrix: Mat<f64> =
         Mat::from_fn(n_points, n_params, |i, j| theta_values[i * n_params + j]);
 
-    let random = settings
-        .parameters()
-        .iter()
-        .filter(|p| !p.fixed)
-        .collect::<Vec<_>>()
-        .iter()
-        .map(|p| (p.name.clone(), p.lower, p.upper))
-        .collect();
-
-    let theta = Theta::from_parts(theta_matrix, random, Vec::new());
+    let theta = Theta::from_parts(theta_matrix, settings.parameters().clone());
 
     Ok(theta)
 }