cmaes 0.2.2

An implementation of the CMA-ES optimization algorithm.
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Handling of different optimization modes (minimize and maximize)

use std::cmp::Ordering;

use crate::utils;

/// The mode to use when optimizing a function.
///
/// The default value is `Minimize`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
    /// Minimize the value of the function.
    Minimize,
    /// Maximize the value of the function.
    Maximize,
}

impl Default for Mode {
    fn default() -> Self {
        Self::Minimize
    }
}

impl Mode {
    /// Compares the two values
    /// For use in sorting
    pub(crate) fn sort_cmp(&self, a: f64, b: f64) -> Ordering {
        match self {
            Mode::Minimize => utils::partial_cmp(a, b),
            Mode::Maximize => utils::partial_cmp(b, a),
        }
    }

    /// Returns whether `a` is a better function value than `b`
    pub(crate) fn is_better(&self, a: f64, b: f64) -> bool {
        match self {
            Mode::Minimize => a < b,
            Mode::Maximize => a > b,
        }
    }

    pub(crate) fn choose_best(&self, a: f64, b: f64) -> f64 {
        match self {
            Mode::Minimize => a.min(b),
            Mode::Maximize => a.max(b),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sort_cmp() {
        assert_eq!(Ordering::Less, Mode::Minimize.sort_cmp(1.0, 2.0));
        assert_eq!(Ordering::Equal, Mode::Minimize.sort_cmp(1.0, 1.0));
        assert_eq!(Ordering::Greater, Mode::Minimize.sort_cmp(2.0, 1.0));

        assert_eq!(Ordering::Greater, Mode::Maximize.sort_cmp(1.0, 2.0));
        assert_eq!(Ordering::Equal, Mode::Maximize.sort_cmp(1.0, 1.0));
        assert_eq!(Ordering::Less, Mode::Maximize.sort_cmp(2.0, 1.0));
    }

    #[test]
    fn test_is_better() {
        assert_eq!(true, Mode::Minimize.is_better(1.0, 2.0));
        assert_eq!(false, Mode::Minimize.is_better(2.0, 2.0));
        assert_eq!(false, Mode::Minimize.is_better(2.0, 1.0));

        assert_eq!(false, Mode::Maximize.is_better(1.0, 2.0));
        assert_eq!(false, Mode::Maximize.is_better(2.0, 2.0));
        assert_eq!(true, Mode::Maximize.is_better(2.0, 1.0));
    }

    #[test]
    fn test_choose_best() {
        assert_eq!(1.0, Mode::Minimize.choose_best(1.0, 2.0));
        assert_eq!(1.0, Mode::Minimize.choose_best(2.0, 1.0));

        assert_eq!(2.0, Mode::Maximize.choose_best(1.0, 2.0));
        assert_eq!(2.0, Mode::Maximize.choose_best(2.0, 1.0));
    }
}