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
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

//! VariableMetricMinimizer: composes seed generator + builder.
//!
//! Replaces VariableMetricMinimizer.h. Orchestrates the Migrad minimization
//! by generating the seed, then running the VariableMetricBuilder loop.

use super::builder::VariableMetricBuilder;
use super::seed::MigradSeedGenerator;
use crate::fcn::FCNGradient;
use crate::minimum::FunctionMinimum;
use crate::mn_fcn::MnFcn;
use crate::strategy::MnStrategy;
use crate::user_transformation::MnUserTransformation;

pub struct VariableMetricMinimizer;

impl VariableMetricMinimizer {
    /// Minimize using numerical gradients (central differences).
    pub fn minimize(
        fcn: &MnFcn,
        trafo: &MnUserTransformation,
        strategy: &MnStrategy,
        maxfcn: usize,
        tolerance: f64,
    ) -> FunctionMinimum {
        let up = fcn.error_def();

        // Generate seed: FCN eval + numerical gradient + V₀
        let seed = MigradSeedGenerator::generate(fcn, trafo, strategy);

        if !seed.is_valid() {
            return FunctionMinimum::new(seed, Vec::new(), up);
        }

        // EDM tolerance: F77 Minuit compatibility factor
        let edmval = tolerance * up * 0.002;

        // Run variable-metric iteration
        let states = VariableMetricBuilder::minimum(fcn, &seed, strategy, maxfcn, edmval);

        // Check outcome
        let nfcn = fcn.num_of_calls();
        if nfcn >= maxfcn {
            FunctionMinimum::with_call_limit(seed, states, up)
        } else if let Some(last) = states.last() {
            if last.edm() > 10.0 * edmval {
                FunctionMinimum::above_max_edm(seed, states, up)
            } else {
                FunctionMinimum::new(seed, states, up)
            }
        } else {
            FunctionMinimum::new(seed, states, up)
        }
    }

    /// Minimize using analytical gradients provided by the user.
    pub fn minimize_with_gradient(
        fcn: &dyn FCNGradient,
        trafo: &MnUserTransformation,
        strategy: &MnStrategy,
        maxfcn: usize,
        tolerance: f64,
    ) -> FunctionMinimum {
        let up = fcn.error_def();

        // Generate seed: FCN eval + analytical gradient + V₀
        let seed = MigradSeedGenerator::generate_with_gradient(fcn, trafo, strategy);

        if !seed.is_valid() {
            return FunctionMinimum::new(seed, Vec::new(), up);
        }

        // EDM tolerance: F77 Minuit compatibility factor
        let edmval = tolerance * up * 0.002;

        // Create a temporary MnFcn for call counting during iteration
        let mn_fcn = MnFcn::new(fcn, trafo);

        // Run variable-metric iteration with analytical gradient calculator
        let states = VariableMetricBuilder::minimum_with_gradient(
            &mn_fcn, fcn, &seed, strategy, maxfcn, edmval,
        );

        // Check outcome
        let nfcn = mn_fcn.num_of_calls();
        if nfcn >= maxfcn {
            FunctionMinimum::with_call_limit(seed, states, up)
        } else if let Some(last) = states.last() {
            if last.edm() > 10.0 * edmval {
                FunctionMinimum::above_max_edm(seed, states, up)
            } else {
                FunctionMinimum::new(seed, states, up)
            }
        } else {
            FunctionMinimum::new(seed, states, up)
        }
    }
}