minuit2 0.4.2

Pure Rust port of CERN Minuit2 parameter optimization engine
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

use minuit2::{MnMigrad, MnMinimize};

#[test]
fn minimize_converges_on_quadratic() {
    let quadratic = |p: &[f64]| p[0] * p[0] + 2.0 * p[1] * p[1];

    let result = MnMinimize::new()
        .add("x", 4.0, 1.0)
        .add("y", -3.0, 1.0)
        .tolerance(0.1)
        .minimize(&quadratic);

    assert!(result.is_valid(), "MnMinimize should converge");
    let params = result.params();
    assert!(
        params[0].abs() < 1e-3,
        "x should be near 0, got {}",
        params[0]
    );
    assert!(
        params[1].abs() < 1e-3,
        "y should be near 0, got {}",
        params[1]
    );

    let migrad = MnMigrad::new()
        .add("x", 4.0, 1.0)
        .add("y", -3.0, 1.0)
        .tolerance(0.1)
        .minimize(&quadratic);
    assert!(migrad.is_valid());

    // Hybrid should be in the same quality regime as pure Migrad on smooth bowls.
    assert!(
        result.fval() < migrad.fval() + 1e-8,
        "MnMinimize fval={} should be comparable to MnMigrad fval={}",
        result.fval(),
        migrad.fval()
    );
}

#[test]
fn minimize_respects_fixed_and_limited_parameters() {
    let constrained = |p: &[f64]| (p[0] - 3.0).powi(2) + (p[1] + 2.0).powi(2);

    let result = MnMinimize::new()
        .add_limited("x", 0.5, 0.5, 0.0, 2.0)
        .add("y", -3.0, 0.5)
        .fix(1) // keep y fixed
        .max_fcn(600)
        .tolerance(0.5)
        .minimize(&constrained);

    assert!(result.is_valid());
    let params = result.params();

    // x optimum is 3 but constrained to [0, 2], so it should end at upper bound.
    assert!(
        (params[0] - 2.0).abs() < 1e-3,
        "x should be at upper bound, got {}",
        params[0]
    );
    // y is fixed to the initial value.
    assert!(
        (params[1] + 3.0).abs() < 1e-12,
        "y should stay fixed at -3, got {}",
        params[1]
    );
}