mop-facades 0.0.6

Facades for MOP
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

use crate::{initial_solutions::InitialSolutions, opt_problem::OptProblem, OptFacade};
use core::{
    default::Default,
    fmt::Debug,
    ops::{Div, Sub},
};
use mop_blocks::Pct;
use mop_common::num_traits::{NumCast, One, Zero};

#[derive(Debug)]
pub struct OptFacadeBuilder<C, D, I, O, OR, S> {
    pub(crate) initial_solutions: Option<I>,
    pub(crate) max_iterations: Option<usize>,
    pub(crate) objs_goals: Vec<OR>,
    pub(crate) opt_problem: Option<OptProblem<C, D, O, OR, S>>,
    pub(crate) stagnation_percentage: Option<Pct>,
    pub(crate) stagnation_threshold: Option<usize>,
}

impl<C, D, I, O, OR, S> OptFacadeBuilder<C, D, I, O, OR, S>
where
    I: InitialSolutions<OptProblem<C, D, O, OR, S>>,
    OR: Copy
        + Debug
        + Div<OR, Output = OR>
        + Default
        + One
        + Zero
        + PartialOrd
        + Send
        + Sub<OR, Output = OR>
        + Sync
        + NumCast,
    S: Copy,
{
    pub fn new() -> Self {
        OptFacadeBuilder {
            initial_solutions: None,
            max_iterations: None,
            objs_goals: vec![],
            opt_problem: None,
            stagnation_percentage: None,
            stagnation_threshold: None,
        }
    }

    pub fn build(mut self) -> OptFacade<C, D, O, OR, S> {
        self.initial_solutions
            .unwrap()
            .initial_solutions(self.opt_problem.as_mut().unwrap());
        OptFacade::new(
            self.max_iterations.unwrap(),
            self.objs_goals,
            self.opt_problem.unwrap(),
            self.stagnation_percentage.unwrap(),
            self.stagnation_threshold.unwrap(),
        )
    }

    pub fn initial_solutions(mut self, initial_solutions: I) -> Self {
        self.initial_solutions = Some(initial_solutions);
        self
    }

    pub fn max_iterations(mut self, max_iterations: usize) -> Self {
        self.max_iterations = Some(max_iterations);
        self
    }

    pub fn objs_goals(mut self, objs_goals: Vec<OR>) -> Self {
        self.objs_goals = objs_goals;
        self
    }

    pub fn opt_problem(mut self, opt_problem: OptProblem<C, D, O, OR, S>) -> Self {
        self.opt_problem = Some(opt_problem);
        self
    }

    pub fn stagnation_percentage(mut self, stagnation_percentage: Pct) -> Self {
        self.stagnation_percentage = Some(stagnation_percentage);
        self
    }

    pub fn stagnation_threshold(mut self, stagnation_threshold: usize) -> Self {
        self.stagnation_threshold = Some(stagnation_threshold);
        self
    }
}

impl<C, D, I, O, OR, S> Default for OptFacadeBuilder<C, D, I, O, OR, S> {
    fn default() -> Self {
        OptFacadeBuilder {
            initial_solutions: None,
            max_iterations: None,
            objs_goals: vec![],
            opt_problem: None,
            stagnation_percentage: None,
            stagnation_threshold: None,
        }
    }
}