mahf 0.1.0

A framework for modular construction and evaluation of metaheuristics.
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

//! State mappings for Simulated Annealing (SA).

use derivative::Derivative;
use eyre::ensure;
use serde::Serialize;

use crate::{
    component::ExecResult,
    components::{
        mapping::{mapping, Mapping},
        Component,
    },
    lens::{AnyLens, ValueLens},
    state::random::Random,
    Problem, State,
};

/// Multiplies the `L::Target` with `alpha`.
///
/// Note that this multiplication is executed on every execution, even within the same iteration.
///
/// This geometric cooling schedule is usually used on the [`Temperature`].
///
/// [`Temperature`]: crate::components::replacement::sa::Temperature
#[derive(Serialize, Derivative)]
#[serde(bound = "")]
#[derivative(Clone(bound = ""))]
pub struct GeometricCooling<L: AnyLens> {
    pub alpha: f64,
    pub lens: L,
}

impl<L: AnyLens> GeometricCooling<L> {
    pub fn from_params(alpha: f64, lens: L) -> ExecResult<Self> {
        ensure!((0.0..1.0).contains(&alpha), "`alpha` must be in [0, 1)");
        Ok(Self { alpha, lens })
    }

    pub fn new<P>(alpha: f64, lens: L) -> ExecResult<Box<dyn Component<P>>>
    where
        P: Problem,
        L: ValueLens<P, f64>,
    {
        Ok(Box::new(Self::from_params(alpha, lens)?))
    }
}

impl<P, L> Mapping<P> for GeometricCooling<L>
where
    P: Problem,
    L: ValueLens<P, f64>,
{
    type Input = f64;
    type Output = f64;

    fn map(&self, value: Self::Input, _rng: &mut Random) -> ExecResult<Self::Output> {
        Ok(value * self.alpha)
    }
}

impl<P, L> Component<P> for GeometricCooling<L>
where
    P: Problem,
    L: ValueLens<P, f64>,
{
    fn execute(&self, problem: &P, state: &mut State<P>) -> ExecResult<()> {
        mapping(self, &self.lens, &self.lens, problem, state)
    }
}