basin 0.7.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

#![cfg(feature = "faer")]
//! Integration tests for the log-barrier [`BarrierMethod`] on linearly
//! constrained quadratics (faer backend) — mirror of
//! `barrier_method_nalgebra.rs`.

use basin::problems::ConstrainedQuadratic;
use basin::{
    Backtracking, BarrierMethod, BasicState, Executor, GradientDescent, GradientState,
    TerminationReason,
};
use faer::{Col, Mat};

/// `min ‖x − (2,2)‖²` s.t. `x₀ + x₁ ≤ 2`; constrained optimum (1, 1).
fn active_problem() -> ConstrainedQuadratic<Mat<f64>, Col<f64>> {
    ConstrainedQuadratic::new(
        Col::from_fn(2, |_| 2.0),
        Mat::from_fn(1, 2, |_, _| 1.0),
        Col::from_fn(1, |_| 2.0),
    )
}

#[test]
fn active_constraint_converges_to_projection() {
    let problem = active_problem();
    let initial = Col::from_fn(2, |_| 0.0); // strictly feasible

    let result = Executor::new(
        problem,
        BarrierMethod::new(GradientDescent::with_line_search(Backtracking::new())),
        BasicState::new(initial),
    )
    .max_iter(50)
    .run();

    assert_eq!(result.reason, TerminationReason::SolverConverged);
    assert!(
        (result.param()[0] - 1.0).abs() < 1e-4 && (result.param()[1] - 1.0).abs() < 1e-4,
        "expected (1, 1), got [{}, {}]",
        result.param()[0],
        result.param()[1]
    );
}

#[test]
fn infeasible_start_is_reported_as_failure() {
    let problem = active_problem();
    let initial = Col::from_fn(2, |_| 2.0); // sum 4 > 2 ⇒ infeasible

    let result = Executor::new(
        problem,
        BarrierMethod::new(GradientDescent::with_line_search(Backtracking::new())),
        BasicState::new(initial),
    )
    .max_iter(50)
    .run();

    assert_eq!(result.reason, TerminationReason::SolverFailed);
}

#[test]
fn two_constraints_both_active() {
    // x₀ + x₁ ≤ 2 and x₀ ≤ 0.5; optimum (0.5, 1.5).
    let problem = ConstrainedQuadratic::new(
        Col::from_fn(2, |_| 2.0),
        // A = [[1, 1], [1, 0]] — all ones except the (1, 1) entry.
        Mat::from_fn(2, 2, |i, j| if i == 1 && j == 1 { 0.0 } else { 1.0 }),
        Col::from_fn(2, |i| if i == 0 { 2.0 } else { 0.5 }),
    );
    let initial = Col::from_fn(2, |_| 0.0);

    let result = Executor::new(
        problem,
        BarrierMethod::new(GradientDescent::with_line_search(Backtracking::new())),
        BasicState::new(initial),
    )
    .max_iter(50)
    .run();

    assert_eq!(result.reason, TerminationReason::SolverConverged);
    assert!(
        (result.param()[0] - 0.5).abs() < 1e-4 && (result.param()[1] - 1.5).abs() < 1e-4,
        "expected (0.5, 1.5), got [{}, {}]",
        result.param()[0],
        result.param()[1]
    );
}

#[test]
fn eval_counts_are_recorded() {
    let problem = active_problem();
    let initial = Col::from_fn(2, |_| 0.0);

    let result = Executor::new(
        problem,
        BarrierMethod::new(GradientDescent::with_line_search(Backtracking::new())),
        BasicState::new(initial),
    )
    .max_iter(50)
    .run();

    assert!(result.cost_evals() > 0, "no cost evals recorded");
    assert!(
        result.state.gradient_evals() > 0,
        "no gradient evals recorded"
    );
}