minuit2 0.4.1

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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use minuit2::{MnMigrad, MnScan};

/// 1D scan of a quadratic: should produce parabolic profile.
#[test]
fn scan_quadratic_profile() {
    let result = MnMigrad::new()
        .add("x", 5.0, 1.0)
        .add("y", -3.0, 1.0)
        .minimize(&|p: &[f64]| p[0] * p[0] + p[1] * p[1]);

    assert!(result.is_valid());

    let scan = MnScan::new(&|p: &[f64]| p[0] * p[0] + p[1] * p[1], &result);
    let points = scan.scan(0, 20, -2.0, 2.0);

    assert!(!points.is_empty());
    assert!(points.len() >= 20);

    // Minimum should be near x=0
    let min_point = points
        .iter()
        .min_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
        .unwrap();
    assert!(
        min_point.0.abs() < 0.3,
        "minimum x should be near 0, got {}",
        min_point.0
    );
}

/// Auto-range scan: default is ±2*error.
#[test]
fn scan_auto_range() {
    let result = MnMigrad::new()
        .add("x", 0.0, 1.0)
        .minimize(&|p: &[f64]| p[0] * p[0]);

    assert!(result.is_valid());

    let scan = MnScan::new(&|p: &[f64]| p[0] * p[0], &result);
    // low == high == 0.0 triggers auto-range
    let points = scan.scan(0, 10, 0.0, 0.0);

    assert!(!points.is_empty());
    // Check range covers roughly ±2*error
    let x_min = points.iter().map(|p| p.0).fold(f64::INFINITY, f64::min);
    let x_max = points.iter().map(|p| p.0).fold(f64::NEG_INFINITY, f64::max);
    assert!(x_min < -0.5, "auto-range should go below 0, got {x_min}");
    assert!(x_max > 0.5, "auto-range should go above 0, got {x_max}");
}

/// Scan finds better minimum.
#[test]
fn scan_minimum_tracking() {
    use minuit2::scan::MnParameterScan;
    use minuit2::user_parameters::MnUserParameters;

    // Start far from minimum.
    let mut params = MnUserParameters::new();
    params.add("x", 10.0, 1.0);

    let fcn = |p: &[f64]| (p[0] - 3.0).powi(2);
    let initial_fval = fcn(&[10.0]);

    let mut scanner = MnParameterScan::new(&fcn, params, initial_fval);
    let _points = scanner.scan(0, 50, 0.0, 6.0);

    // Scanner should have found a better point near x=3.
    assert!(
        scanner.fval() < initial_fval,
        "scanner should find better fval"
    );
    assert!(
        (scanner
            .params()
            .value("x")
            .expect("parameter x should exist")
            - 3.0)
            .abs()
            < 0.5,
        "tracked minimum should move from 10 to near 3"
    );
}

/// nsteps is clamped to [2, 101], and bounded scan ranges are clamped to limits.
#[test]
fn scan_range_and_step_clamping() {
    let result = MnMigrad::new()
        .add_limited("x", 3.0, 1.0, 0.0, 2.0)
        .add("y", -1.0, 1.0)
        .minimize(&|p: &[f64]| (p[0] - 1.0).powi(2) + p[1] * p[1]);

    assert!(result.is_valid());

    let scan = MnScan::new(&|p: &[f64]| (p[0] - 1.0).powi(2) + p[1] * p[1], &result);

    // nsteps is clamped below range to 2.
    let points = scan.scan(0, 0, -10.0, 10.0);
    assert_eq!(points.len(), 3);

    let x_min = points.iter().map(|v| v.0).fold(f64::INFINITY, f64::min);
    let x_max = points.iter().map(|v| v.0).fold(f64::NEG_INFINITY, f64::max);
    assert!((x_min - 0.0).abs() < 1e-12);
    assert!((x_max - 2.0).abs() < 1e-12);
}

/// `scan()` and `scan_serial()` should be equivalent.
#[test]
fn scan_default_matches_serial() {
    let result = MnMigrad::new()
        .add("x", 5.0, 1.0)
        .add("y", -3.0, 1.0)
        .minimize(&|p: &[f64]| p[0] * p[0] + p[1] * p[1]);

    assert!(result.is_valid());

    let scan = MnScan::new(&|p: &[f64]| p[0] * p[0] + p[1] * p[1], &result);
    let points_default = scan.scan(0, 25, -2.5, 2.5);
    let points_serial = scan.scan_serial(0, 25, -2.5, 2.5);

    assert_eq!(points_default.len(), points_serial.len());
    for (a, b) in points_default.iter().zip(points_serial.iter()) {
        assert!((a.0 - b.0).abs() < 1e-12);
        assert!((a.1 - b.1).abs() < 1e-12);
    }
}

/// Parallel scan should match serial results.
#[cfg(feature = "parallel")]
#[test]
fn scan_parallel_matches_serial() {
    let result = MnMigrad::new()
        .add("x", 1.5, 0.5)
        .add("y", -0.5, 0.5)
        .minimize(&|p: &[f64]| {
            // Slightly non-trivial shape to exercise full scan path.
            (p[0] - 0.2).powi(2) + 2.0 * (p[1] + 0.4).powi(2) + 0.1 * p[0] * p[1]
        });

    assert!(result.is_valid());

    let fcn = |p: &[f64]| (p[0] - 0.2).powi(2) + 2.0 * (p[1] + 0.4).powi(2) + 0.1 * p[0] * p[1];
    let scan = MnScan::new(&fcn, &result);
    let serial = scan.scan_serial(0, 40, -2.0, 2.0);
    let parallel = scan.scan_parallel(0, 40, -2.0, 2.0);

    assert_eq!(serial.len(), parallel.len());
    for (a, b) in serial.iter().zip(parallel.iter()) {
        assert!((a.0 - b.0).abs() < 1e-12);
        assert!((a.1 - b.1).abs() < 1e-12);
    }
}