oxieml 0.1.2

EML operator: all elementary functions from exp(x) - ln(y)
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

//! Pareto-dominance utilities for discovered formulas.
//!
//! Provides [`pareto_front`] and the `dominates` method on [`DiscoveredFormula`].

use super::DiscoveredFormula;

impl DiscoveredFormula {
    /// Returns `true` if `self` Pareto-dominates `other`.
    ///
    /// `self` dominates `other` when it is at least as good on every objective
    /// (MSE and complexity) and strictly better on at least one.
    pub fn dominates(&self, other: &DiscoveredFormula) -> bool {
        self.mse <= other.mse
            && self.complexity <= other.complexity
            && (self.mse < other.mse || self.complexity < other.complexity)
    }
}

/// Extract the Pareto-optimal subset from a slice of discovered formulas.
///
/// A formula F is Pareto-optimal if no other formula G dominates it
/// (i.e., G has both lower-or-equal MSE **and** lower-or-equal complexity,
/// with at least one strictly lower).
///
/// The returned vector is sorted by complexity ascending (simplest first).
/// If `formulas` is empty, returns an empty vector.
/// Time complexity: O(n²) — acceptable for the formula counts typical of EML.
pub fn pareto_front(formulas: &[DiscoveredFormula]) -> Vec<DiscoveredFormula> {
    let mut front: Vec<DiscoveredFormula> = formulas
        .iter()
        .filter(|candidate| !formulas.iter().any(|other| other.dominates(candidate)))
        .cloned()
        .collect();

    front.sort_by(|a, b| {
        a.complexity.cmp(&b.complexity).then_with(|| {
            a.mse
                .partial_cmp(&b.mse)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
    });
    front
}

/// Returns `true` if `a` dominates `b` with respect to complexity and a custom
/// objective function `objective`.
///
/// Dominance: `a.complexity ≤ b.complexity` AND `objective(a) < objective(b)`.
pub fn dominates_by<F>(a: &DiscoveredFormula, b: &DiscoveredFormula, objective: F) -> bool
where
    F: Fn(&DiscoveredFormula) -> f64,
{
    a.complexity <= b.complexity && objective(a) < objective(b)
}

/// Pareto-optimal subset ranked by (complexity, AIC) or (complexity, BIC).
///
/// A formula F is on the IC-Pareto front if no other formula G has both
/// lower-or-equal complexity and strictly lower IC value.
///
/// The returned vector is sorted by complexity ascending. If `formulas` is
/// empty, returns an empty vector.
pub fn pareto_front_ic(formulas: &[DiscoveredFormula], use_bic: bool) -> Vec<DiscoveredFormula> {
    let ic_of = |f: &DiscoveredFormula| if use_bic { f.bic } else { f.aic };

    let mut front: Vec<DiscoveredFormula> = formulas
        .iter()
        .filter(|candidate| {
            !formulas
                .iter()
                .any(|other| dominates_by(other, candidate, ic_of))
        })
        .cloned()
        .collect();

    front.sort_by_key(|a| a.complexity);
    front
}