basin 3.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
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
106
107
108
109
110
111

#![cfg(all(feature = "ndarray_all", feature = "problems"))]

use crate::backend_aliases::ndarray::Array1;
use basin::problems::BoothBoxed;
use basin::{
    Backtracking, Executor, FirstOrderState, ProjectedGradientDescent,
    TerminationCode,
};

#[test]
fn slack_bounds_recover_unconstrained_minimum() {
    let lower = Array1::from(vec![-5.0, -5.0]);
    let upper = Array1::from(vec![5.0, 5.0]);
    let problem = BoothBoxed::<Array1<f64>>::new(lower, upper);
    let initial = Array1::from(vec![0.0, 0.0]);

    let result = Executor::new(
        problem,
        ProjectedGradientDescent::with_line_search(Backtracking::new()),
        FirstOrderState::new(initial),
    )
    .max_iter(2000)
    .run()
    .unwrap();

    assert!(
        (result.param()[0] - 1.0).abs() < 1e-4,
        "x[0] = {}",
        result.param()[0]
    );
    assert!(
        (result.param()[1] - 3.0).abs() < 1e-4,
        "x[1] = {}",
        result.param()[1]
    );
}

#[test]
fn tight_bounds_converge_to_box_corner() {
    let lower = Array1::from(vec![-1.0, -1.0]);
    let upper = Array1::from(vec![1.0, 1.0]);
    let problem = BoothBoxed::<Array1<f64>>::new(lower, upper);
    let initial = Array1::from(vec![0.0, 0.0]);

    let result = Executor::new(
        problem,
        ProjectedGradientDescent::with_line_search(Backtracking::new()),
        FirstOrderState::new(initial),
    )
    .max_iter(2000)
    .run()
    .unwrap();

    assert!(
        (result.param()[0] - 1.0).abs() < 1e-6,
        "x[0] = {}",
        result.param()[0]
    );
    assert!(
        (result.param()[1] - 1.0).abs() < 1e-6,
        "x[1] = {}",
        result.param()[1]
    );
}

#[test]
fn infeasible_initial_param_is_projected_at_init() {
    let lower = Array1::from(vec![-1.0, -1.0]);
    let upper = Array1::from(vec![1.0, 1.0]);
    let problem = BoothBoxed::<Array1<f64>>::new(lower, upper);
    let initial = Array1::from(vec![10.0, 10.0]);

    let result = Executor::new(
        problem,
        ProjectedGradientDescent::new(0.01),
        FirstOrderState::new(initial),
    )
    .max_iter(0)
    .run()
    .unwrap();

    assert_eq!(result.report.code(), TerminationCode::MaxIter);
    assert_eq!(result.param()[0], 1.0);
    assert_eq!(result.param()[1], 1.0);
}

#[test]
fn projected_gradient_tolerance_triggers_at_corner_minimum() {
    let lower = Array1::from(vec![-1.0, -1.0]);
    let upper = Array1::from(vec![1.0, 1.0]);
    let problem = BoothBoxed::<Array1<f64>>::new(lower.clone(), upper.clone());
    let initial = Array1::from(vec![0.0, 0.0]);

    let result = Executor::new(
        problem,
        (ProjectedGradientDescent::with_line_search(Backtracking::new()))
            .with_absolute_projected_gradient_tolerance(1e-7),
        FirstOrderState::new(initial),
    )
    .max_iter(2000)
    .run()
    .unwrap();

    assert_eq!(
        result.report.code(),
        TerminationCode::ProjectedGradientTolerance
    );
}

#[path = "support/backend_aliases.rs"]
mod backend_aliases;