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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use core::ops::{AddAssign, Deref, Div, Rem, Sub};

use num::{traits::Euclid, One, Zero};

use array_math::SliceMath;

use crate::quantities::{Lists, MaybeList, NotPolynomial, Polynomial};

impl<T, C1, C2> Div<Polynomial<T, C2>> for Polynomial<T, C1>
where
    T: Zero + One + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,
    C1: MaybeList<T>,
    C2: MaybeList<T>,
{
    type Output = Polynomial<T, Vec<T>>;

    fn div(self, rhs: Polynomial<T, C2>) -> Self::Output
    {
        let one = T::one();
        let (mut q, _): (Vec<_>, Vec<_>) = self.deref()
            .as_view_slice_option()
            .unwrap_or_else(|| core::slice::from_ref(&one))
            .deconvolve_direct(rhs.deref()
                .as_view_slice_option()
                .unwrap_or_else(|| core::slice::from_ref(&one))
            ).unwrap();
        while let Some(q0) = q.first() && q0.is_zero()
        {
            q.remove(0);
        }
        Polynomial::new(q)
    }
}

impl<T1, T2, T3, C> Div<T2> for Polynomial<T1, C>
where
    C: Lists<T1>,
    T2: NotPolynomial + Clone,
    T1: Div<T2, Output = T3> + Clone,
    C::Mapped<T3>: Lists<T3>
{
    type Output = Polynomial<T3, C::Mapped<T3>>;

    #[inline]
    fn div(self, rhs: T2) -> Self::Output
    {
        self.map_into_owned(|lhs| lhs/rhs.clone())
    }
}

impl<T, C1, C2> Rem<Polynomial<T, C2>> for Polynomial<T, C1>
where
    T: Zero + One + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,
    C1: MaybeList<T>,
    C2: MaybeList<T>,
{
    type Output = Polynomial<T, Vec<T>>;

    #[inline]
    fn rem(self, rhs: Polynomial<T, C2>) -> Self::Output
    {
        let one = T::one();
        let (_, mut r): (Vec<_>, Vec<_>) = self.deref()
            .as_view_slice_option()
            .unwrap_or_else(|| core::slice::from_ref(&one))
            .deconvolve_direct(rhs.deref()
                .as_view_slice_option()
                .unwrap_or_else(|| core::slice::from_ref(&one))
            ).unwrap();
        while let Some(r0) = r.first() && r0.is_zero()
        {
            r.remove(0);
        }
        Polynomial::new(r)
    }
}

impl<T> Euclid for Polynomial<T, Vec<T>>
where
    T: Zero + One + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,
{
    #[inline]
    fn div_euclid(&self, v: &Self) -> Self
    {
        let (mut q, _): (Vec<_>, Vec<_>) = self.deconvolve_direct(v.deref())
            .unwrap();
        while let Some(q0) = q.first() && q0.is_zero()
        {
            q.remove(0);
        }
        Polynomial::new(q)
    }
    
    #[inline]
    fn rem_euclid(&self, v: &Self) -> Self
    {
        let (_, mut r): (Vec<_>, Vec<_>) = self.deconvolve_direct(v.deref())
            .unwrap();
        while let Some(r0) = r.first() && r0.is_zero()
        {
            r.remove(0);
        }
        Polynomial::new(r)
    }

    #[inline]
    fn div_rem_euclid(&self, v: &Self) -> (Self, Self)
    {
        let (mut q, mut r): (Vec<_>, Vec<_>) = self.deconvolve_direct(v.deref())
            .unwrap();
        while let Some(q0) = q.first() && q0.is_zero()
        {
            q.remove(0);
        }
        while let Some(r0) = r.first() && r0.is_zero()
        {
            r.remove(0);
        }
        (Polynomial::new(q), Polynomial::new(r))
    }
}