nacfahi 0.5.1

Simpler, but less error-prone API for `levenberg-marquardt` optimization crate
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

use core::ops::Mul;

use generic_array::GenericArray;
use num_traits::{FloatConst, Pow};
use typenum::U2;

use crate::models::{FitModel, FitModelErrors, FitModelXDeriv};

/// Exponent model $a \cdot \exp(b \cdot x )$
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Exponent<Scalar> {
    /// Constant in front of the exponent
    pub a: Scalar,
    /// Exponent multiplier
    pub b: Scalar,
}

impl<Scalar: Clone + Mul<Output = Scalar> + Pow<Scalar, Output = Scalar> + FloatConst> FitModel
    for Exponent<Scalar>
{
    type Scalar = Scalar;
    type ParamCount = U2;

    #[inline]
    fn evaluate(&self, x: &Self::Scalar) -> Scalar {
        self.a.clone() * (Self::Scalar::E().pow(self.b.clone() * x.clone()))
    }

    #[inline]
    fn jacobian(
        &self,
        x: &Self::Scalar,
    ) -> impl Into<GenericArray<Self::Scalar, Self::ParamCount>> {
        // y = a * exp(bx)
        // - derivative over a is exp(bx)
        // - derivative over b is ax * exp(bx)
        let e_x = Self::Scalar::E().pow(self.b.clone() * x.clone());
        [e_x.clone(), self.a.clone() * x.clone() * e_x]
    }

    #[inline]
    fn set_params(&mut self, new_params: GenericArray<Self::Scalar, Self::ParamCount>) {
        let [new_a, new_b] = new_params.into_array();
        self.a = new_a;
        self.b = new_b;
    }

    #[inline]
    fn get_params(&self) -> impl Into<GenericArray<Self::Scalar, Self::ParamCount>> {
        [self.a.clone(), self.b.clone()]
    }
}

impl<Scalar: Clone + Mul<Output = Scalar> + Pow<Scalar, Output = Scalar> + FloatConst>
    FitModelXDeriv for Exponent<Scalar>
{
    #[inline]
    fn deriv_x(&self, x: &Self::Scalar) -> Self::Scalar {
        // y = a * exp(bx)
        // - derivative over x is ab * exp(bx)
        self.a.clone() * self.b.clone() * Scalar::E().pow(self.b.clone() * x.clone())
    }
}

impl<Scalar: 'static> FitModelErrors for Exponent<Scalar>
where
    Scalar: Clone + Mul<Output = Scalar> + Pow<Scalar, Output = Scalar> + FloatConst,
{
    type OwnedModel = Self;

    #[inline]
    fn with_errors(errors: GenericArray<Self::Scalar, Self::ParamCount>) -> Self::OwnedModel {
        let [a, b] = errors.into_array();
        Exponent { a, b }
    }
}

#[cfg(test)]
mod tests;