signal_processing 0.3.0

A signal processing library.
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

use core::ops::Mul;

use num::{Float, Zero};
use option_trait::{Maybe, StaticMaybe};

use crate::quantities::{IntoList, ListOrSingle};

pub trait PulseTrain<T, L, N>: IntoList<T, L, N>
where
    T: Float,
    L: ListOrSingle<T>,
    N: Maybe<usize>
{
    fn pulse_train<D, G, GG, P, R, O>(self, numtaps: N, train: D, pulse: P, fold: R) -> (D::Mapped<L::Mapped<O>>, L::Mapped<O>, L)
    where
        D: ListOrSingle<(T, GG)>,
        GG: StaticMaybe<G, MaybeOr<G, T> = G> + Clone,
        G: Clone,
        D::Mapped<L::Mapped<O>>: ListOrSingle<L::Mapped<O>>,
        L::Mapped<O>: ListOrSingle<O>,
        P: FnMut<(T,)>,
        R: Fn(O, O) -> O,
        O: Zero + Clone,
        P::Output: Clone + Mul<G, Output = O>;
}

impl<T, L, RR, N> PulseTrain<T, L, N> for RR
where
    T: Float,
    L: ListOrSingle<T>,
    RR: IntoList<T, L, N>,
    N: Maybe<usize>
{
    fn pulse_train<D, G, GG, P, R, O>(self, n: N, train: D, mut pulse: P, fold: R) -> (D::Mapped<L::Mapped<O>>, L::Mapped<O>, L)
    where
        D: ListOrSingle<(T, GG)>,
        GG: StaticMaybe<G, MaybeOr<G, T> = G> + Clone,
        G: Clone,
        D::Mapped<L::Mapped<O>>: ListOrSingle<L::Mapped<O>>,
        L::Mapped<O>: ListOrSingle<O>,
        P: FnMut<(T,)>,
        R: Fn(O, O) -> O,
        O: Zero + Clone,
        P::Output: Clone + Mul<G, Output = O>
    {
        let t = self.into_list(n);

        let s = train.map_into_owned(|(d, g)| {
            let g: G = g.into_option()
                .unwrap_or_else(|| unsafe {core::mem::transmute_copy(&T::one())});
            t.map_to_owned(|&t| {
                pulse(t - d)*g.clone()
            })
        });

        let ss = s.as_view_slice();

        let mut i = 0;
        let y = t.map_to_owned(|_| {
            let y = ss.iter()
                .map(|s| s.as_view_slice()[i].clone())
                .reduce(&fold)
                .unwrap_or_else(O::zero);
            i += 1;
            y
        });

        (s, y, t)
    }
}

#[cfg(test)]
mod test
{
    use core::ops::Add;

    use array_math::ArrayOps;

    use crate::{plot, gen::pulse::{GausPuls, PulseTrain}};

    #[test]
    fn test()
    {
        const N: usize = 1024;
        let (_s, y, t): (_, [_; N], _) = (0.0..=8.0).pulse_train((), [
            (1.0, 1.0),
            (3.0, 0.66),
            (6.0, 0.33)
        ], |x| {
            let ([y], [_], [_], [_]) = [x].gauspuls((), 5.0, 0.5);
            y
        }, Add::add);

        plot::plot_curves("y(t)", "plots/y_t_pulse_train.png", [&t.zip(y)])
            .unwrap()
    }
}