roma_lib 0.1.2

A Rust metaheuristics framework inspired by jMetal for optimization and experimentation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/// Bounds metadata for real-valued search spaces.
///
/// This type lives in the solution module because it describes constraints on
/// real-valued decision variables and is consumed directly by solution builders
/// and real-valued operators.
///
/// Problems may expose a shared `RealBounds` instance through
/// `Problem::real_bounds()`, but the type itself is solution-facing metadata.
#[derive(Clone, Debug, PartialEq)]
pub enum RealBounds {
    Uniform {
        lower: f64,
        upper: f64,
        dimensions: usize,
    },
    PerVariable {
        lower_bounds: Vec<f64>,
        upper_bounds: Vec<f64>,
    },
}

impl RealBounds {
    pub fn uniform(lower: f64, upper: f64, dimensions: usize) -> Self {
        debug_assert!(lower <= upper, "lower bound must not exceed upper bound");

        Self::Uniform {
            lower,
            upper,
            dimensions,
        }
    }

    pub fn per_variable(lower_bounds: Vec<f64>, upper_bounds: Vec<f64>) -> Self {
        debug_assert_eq!(
            lower_bounds.len(),
            upper_bounds.len(),
            "lower and upper bounds should have the same length"
        );

        Self::PerVariable {
            lower_bounds,
            upper_bounds,
        }
    }

    pub fn bounds_at(&self, index: usize) -> Option<(f64, f64)> {
        match self {
            Self::Uniform {
                lower,
                upper,
                dimensions,
            } => (index < *dimensions).then_some((*lower, *upper)),
            Self::PerVariable {
                lower_bounds,
                upper_bounds,
            } => Some((
                lower_bounds.get(index).copied()?,
                upper_bounds.get(index).copied()?,
            )),
        }
    }

    pub fn clamp(&self, index: usize, value: f64) -> Option<f64> {
        self.bounds_at(index)
            .map(|(lower, upper)| value.clamp(lower, upper))
    }
}