Skip to main content

autoeq_optim/
problem.rs

1use std::sync::Arc;
2
3/// Scalar objective evaluated by an optimizer backend.
4pub trait ObjectiveEvaluator: Send + Sync {
5    fn evaluate(&self, parameters: &[f64]) -> f64;
6}
7
8impl<F> ObjectiveEvaluator for F
9where
10    F: Fn(&[f64]) -> f64 + Send + Sync,
11{
12    fn evaluate(&self, parameters: &[f64]) -> f64 {
13        self(parameters)
14    }
15}
16
17/// Backend-independent optimization problem.
18#[derive(Clone)]
19pub struct OptimizationProblem {
20    pub lower_bounds: Vec<f64>,
21    pub upper_bounds: Vec<f64>,
22    pub objective: Arc<dyn ObjectiveEvaluator>,
23    pub integrality: Option<Vec<bool>>,
24}
25
26impl OptimizationProblem {
27    pub fn new(
28        lower_bounds: Vec<f64>,
29        upper_bounds: Vec<f64>,
30        objective: impl ObjectiveEvaluator + 'static,
31    ) -> Self {
32        Self {
33            lower_bounds,
34            upper_bounds,
35            objective: Arc::new(objective),
36            integrality: None,
37        }
38    }
39
40    pub fn validate(&self) -> Result<(), String> {
41        if self.lower_bounds.len() != self.upper_bounds.len() {
42            return Err("lower and upper bounds must have equal lengths".to_string());
43        }
44        if self
45            .lower_bounds
46            .iter()
47            .zip(&self.upper_bounds)
48            .any(|(lower, upper)| !lower.is_finite() || !upper.is_finite() || lower > upper)
49        {
50            return Err("optimization bounds must be finite and ordered".to_string());
51        }
52        if let Some(integrality) = &self.integrality
53            && integrality.len() != self.lower_bounds.len()
54        {
55            return Err("integrality length must match bounds length".to_string());
56        }
57        Ok(())
58    }
59}
60
61#[derive(Debug, Clone, PartialEq)]
62pub struct OptimizationResult {
63    pub parameters: Vec<f64>,
64    pub objective: f64,
65    pub status: String,
66}
67
68#[cfg(test)]
69mod tests {
70    use super::*;
71
72    #[test]
73    fn validates_neutral_problem_shape() {
74        let problem =
75            OptimizationProblem::new(vec![0.0, 1.0], vec![1.0, 2.0], |x: &[f64]| x.iter().sum());
76        assert!(problem.validate().is_ok());
77        assert_eq!(problem.objective.evaluate(&[2.0, 3.0]), 5.0);
78    }
79
80    #[test]
81    fn rejects_mismatched_bounds_and_integrality() {
82        let mut problem = OptimizationProblem::new(vec![0.0], vec![1.0, 2.0], |_: &[f64]| 0.0);
83        assert!(problem.validate().is_err());
84        problem.upper_bounds = vec![1.0];
85        problem.integrality = Some(vec![true, false]);
86        assert!(problem.validate().is_err());
87    }
88}