optimum 0.0.4

Future Framework to solve optimization problems
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

//! See [Solver].

use crate::core::stop_criterion::StopCriterion;

use super::{Comparison, Evaluation, Problem};

/// A solver is a procedure which seeks to find a good solution for a given [Problem].
///
/// There's two kinds of solvers:
/// - Metaheuristics
///     - They are generic over the [Problem] being solved.
/// - Heuristics
///     - They're [Problem]-specific.
pub trait Solver<SC: StopCriterion<Self::P>, H: IterHook<Self::P>> {
    /// The problem being solved
    type P: Problem;

    /// A iteration consists on a step to generate a candidate solution
    fn iterate(&mut self, stop_criterion: &mut SC, hook: &mut H) -> Option<Evaluation<Self::P>>;

    /// Execute the whole process defined by the solver to achieve a good solution
    ///
    /// By default, it executes [iterate][Self::iterate] while the stop criterion isn't met and returns
    /// the best solution found among all iterations.
    fn solve(&mut self, stop_criterion: &mut SC, hook: &mut H) -> Option<Evaluation<Self::P>> {
        let mut best_evaluation = self.iterate(stop_criterion, hook)?;
        hook.iterated(&best_evaluation);
        stop_criterion.update(best_evaluation.value());

        while !stop_criterion.should_stop() {
            let candidate = {
                match self.iterate(stop_criterion, hook) {
                    Some(s) => s,
                    None => break,
                }
            };

            stop_criterion.update(candidate.value());
            hook.iterated(&candidate);

            if let Comparison::Better = candidate.compare(&best_evaluation) {
                hook.better_changed(&best_evaluation, &candidate);
                best_evaluation = candidate
            }
        }

        Some(best_evaluation)
    }
}

pub mod hook;

pub use hook::IterHook;