enterpolation 0.3.0

A library for creating and computing interpolations, extrapolations and smoothing of generic data points.
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

//! Module with structures for homogeneous datapoints, non-uniform inerpolations, weighted interpolations
//! and adapters to handle these better.

mod homogeneous;
mod weighted;

pub use homogeneous::Homogeneous;
pub use weighted::Weighted;

use crate::{Chain, ConstChain, Curve, Signal};
use core::ops::Mul;
use num_traits::identities::Zero;
use num_traits::real::Real;

/// Signal adaptor to transform `(T,R)` to `Homogeneous<T,R>`.
///
/// Weights given by the signal who equal `R::zero()` are considered to be at infinity.
#[derive(Debug, Copy, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub struct Weights<G> {
    signal: G,
}

impl<G> Weights<G> {
    /// Transform given signal such that it outputs homogeneous data.
    pub fn new(signal: G) -> Self {
        Weights { signal }
    }
}

impl<G, Input> Signal<Input> for Weights<G>
where
    G: Signal<Input>,
    G::Output: IntoWeight,
{
    type Output =
        Homogeneous<<G::Output as IntoWeight>::Element, <G::Output as IntoWeight>::Weight>;
    fn eval(&self, input: Input) -> Self::Output {
        self.signal.eval(input).into_weight()
    }
}

impl<G> Chain for Weights<G>
where
    G: Chain,
    G::Output: IntoWeight,
{
    fn len(&self) -> usize {
        self.signal.len()
    }
}

impl<G, const N: usize> ConstChain<N> for Weights<G>
where
    G: ConstChain<N>,
    G::Output: IntoWeight,
{
}

impl<C, R> Curve<R> for Weights<C>
where
    C: Curve<R>,
    C::Output: IntoWeight,
    R: Real,
{
    fn domain(&self) -> [R; 2] {
        self.signal.domain()
    }
}

/// Trait for all structs which can be transformed into homogeneous data.
///
/// This trait is used to be able to implement Signals for Weights without having to add other generic variables.
pub trait IntoWeight {
    /// The element/direction of the homogeneous data.
    type Element;
    /// The weight/rational of the homogeneous data.
    type Weight;
    /// Method to convert self into homogeneous data.
    fn into_weight(self) -> Homogeneous<Self::Element, Self::Weight>;
}

impl<T, R> IntoWeight for (T, R)
where
    T: Mul<R, Output = T>,
    R: Zero + Copy,
{
    type Element = T;
    type Weight = R;
    fn into_weight(self) -> Homogeneous<T, R> {
        Homogeneous::weighted_or_infinite(self.0, self.1)
    }
}

impl<T, R> IntoWeight for Homogeneous<T, R>
where
    T: Mul<R, Output = T>,
    R: Zero + Copy,
{
    type Element = T;
    type Weight = R;
    fn into_weight(self) -> Homogeneous<T, R> {
        self
    }
}