basin 2.0.0

Numerical optimization in pure Rust, with pluggable linear-algebra backends and WASM support.
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

use super::{ObservationEvent, Observe, ObserveSolver};
use crate::core::termination::TerminationReport;

// Adapting state observers keeps both kinds in one registration-ordered list
// with one dynamic call per callback and no bounds on state or solver storage.
pub(crate) struct StateObserver<O>(pub(crate) O);

impl<S: crate::State, So, O: Observe<S>> ObserveSolver<S, So>
    for StateObserver<O>
{
    fn observe_init(&mut self, state: &S, _solver: &So) {
        self.0.observe_init(state);
    }

    fn observe_iter(&mut self, state: &S, _solver: &So) {
        self.0.observe_iter(state);
    }

    fn observe_final(
        &mut self,
        state: &S,
        _solver: &So,
        reason: &TerminationReport<S::Float>,
    ) {
        self.0.observe_final(state, reason);
    }
}

pub(crate) struct SolverCallback<C>(pub(crate) C);

impl<S: crate::State, So, C> ObserveSolver<S, So> for SolverCallback<C>
where
    C: FnMut(&S, &So, ObservationEvent<'_, S::Float>),
{
    fn observe_init(&mut self, state: &S, solver: &So) {
        (self.0)(state, solver, ObservationEvent::Init);
    }

    fn observe_iter(&mut self, state: &S, solver: &So) {
        (self.0)(state, solver, ObservationEvent::Iter);
    }

    fn observe_final(
        &mut self,
        state: &S,
        solver: &So,
        reason: &TerminationReport<S::Float>,
    ) {
        (self.0)(state, solver, ObservationEvent::Final(reason));
    }
}