rsl-interpolation 0.1.18

A re-write of GSL's Interpolation Routines in Rust.
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

use std::ops::Deref;

use crate::InterpType;
use crate::Interpolation;
use crate::InterpolationError;

/// 1D Interpolator with runtime-determined Interpolation Type.
pub type DynInterpolation<T> = Box<dyn Interpolation<T> + Send + Sync + 'static>;

/// Representation of an Interpolation Type that is not known in compile-time.
pub struct DynInterpType<T> {
    #[allow(clippy::type_complexity)]
    build: Box<
        dyn Fn(&[T], &[T]) -> Result<DynInterpolation<T>, InterpolationError>
            + Send
            + Sync
            + 'static,
    >,
    name: Box<str>,
    min_size: usize,
}

impl<T> DynInterpType<T> {
    pub fn new<I>(interp: I) -> Self
    where
        I: InterpType<T> + Send + Sync + 'static,
        I::Interpolation: Send + Sync + 'static,
    {
        Self {
            name: interp.name().into(),
            min_size: interp.min_size(),
            build: Box::new(move |xa, ya| match interp.build(xa, ya) {
                Ok(interp) => Ok(Box::new(interp)),
                Err(err) => Err(err),
            }),
        }
    }
}

impl<T> InterpType<T> for DynInterpType<T> {
    type Interpolation = DynInterpolation<T>;

    fn build(&self, xa: &[T], ya: &[T]) -> Result<DynInterpolation<T>, InterpolationError> {
        (self.build)(xa, ya)
    }

    fn name(&self) -> &str {
        &self.name
    }

    fn min_size(&self) -> usize {
        self.min_size
    }
}

impl<T> Interpolation<T> for DynInterpolation<T> {
    fn eval(
        &self,
        xa: &[T],
        ya: &[T],
        x: T,
        acc: &mut crate::Accelerator,
    ) -> Result<T, crate::DomainError> {
        self.deref().eval(xa, ya, x, acc)
    }

    fn eval_deriv(
        &self,
        xa: &[T],
        ya: &[T],
        x: T,
        acc: &mut crate::Accelerator,
    ) -> Result<T, crate::DomainError> {
        self.deref().eval_deriv(xa, ya, x, acc)
    }

    fn eval_deriv2(
        &self,
        xa: &[T],
        ya: &[T],
        x: T,
        acc: &mut crate::Accelerator,
    ) -> Result<T, crate::DomainError> {
        self.deref().eval_deriv2(xa, ya, x, acc)
    }

    fn eval_integ(
        &self,
        xa: &[T],
        ya: &[T],
        a: T,
        b: T,
        acc: &mut crate::Accelerator,
    ) -> Result<T, crate::DomainError> {
        self.deref().eval_integ(xa, ya, a, b, acc)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::*;

    #[test]
    fn test_dyn_interp_type() {
        let xa = [1.0, 2.0, 3.0];
        let ya = [1.0, 2.0, 3.0];

        let mut acc = Accelerator::new();
        let interp: DynInterpolation<f64> = DynInterpType::new(Cubic).build(&xa, &ya).unwrap();
        let _ = interp.eval(&xa, &ya, 1.5, &mut acc).unwrap();
    }
}