roma_lib 0.1.0

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::fmt::Display;

use crate::solution::traits::Dominance;
use crate::solution::Solution;

/// Trait that defines the basic interface for sets of solutions.
/// * `T` - Type of the solution variables
/// * `Q` - Quality payload type (defaults to `f64`)
pub trait SolutionSet<T, Q = f64>
where
    T: Clone,
    Q: Clone + Dominance + Display,
{
    /// Returns an iterator over all solutions in the set.
    fn iter(&self) -> Box<dyn Iterator<Item = &Solution<T, Q>> + '_>;

    /// Appends one solution to the set.
    fn push_solution(&mut self, solution: Solution<T, Q>);

    /// Removes one solution from the tail of the set semantics.
    fn pop_solution(&mut self) -> Option<Solution<T, Q>>;

    /// Removes all solutions from the set.
    fn clear_solutions(&mut self);

    /// Returns one solution by index when indexable.
    fn get_solution(&self, index: usize) -> Option<&Solution<T, Q>>;

    /// Returns one mutable solution by index when indexable.
    fn get_solution_mut(&mut self, index: usize) -> Option<&mut Solution<T, Q>>;

    /// Returns the number of solutions in the set.
    fn len(&self) -> usize;

    fn add_solution(&mut self, solution: Solution<T, Q>) {
        self.push_solution(solution);
    }

    /// Remove the last solution
    fn remove_solution(&mut self) -> Option<Solution<T, Q>> {
        self.pop_solution()
    }

    /// Remove all the solutions
    fn clear(&mut self) {
        self.clear_solutions();
    }

    /// Contains some solution
    fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Number of solutions
    fn size(&self) -> usize {
        self.len()
    }

    /// Returns the best solution according to `Dominance`.
    ///
    /// This works for both scalar and multi-objective quality payloads because
    /// the comparison logic is delegated to `Q: Dominance`.
    fn best_solution(&self) -> Option<&Solution<T, Q>> {
        let mut best: Option<&Solution<T, Q>> = None;
        for solution in self.iter() {
            let is_better = match best {
                Some(current_best) => solution.dominates(current_best),
                None => true,
            };

            if is_better {
                best = Some(solution);
            }
        }

        best
    }

    /// Returns the scalar value of the best solution, if any.
    fn best_solution_value(&self) -> Option<f64>
    where
        Q: Copy + Into<f64> + Display,
        T: Display,
    {
        self.best_solution()
            .and_then(|s| s.quality().map(|&q| q.into()))
    }

    /// Returns the scalar value of the best solution, or `default` when empty.
    fn best_solution_value_or(&self, default: f64) -> f64
    where
        Q: Copy + Into<f64>,
        T: Display,
    {
        self.best_solution_value().unwrap_or(default)
    }

    fn get(&self, index: usize) -> Option<&Solution<T, Q>> {
        self.get_solution(index)
    }

    fn get_mut(&mut self, index: usize) -> Option<&mut Solution<T, Q>> {
        self.get_solution_mut(index)
    }
}