flaw 0.6.1

Embedded signal filtering, no-std and no-alloc compatible.
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

use num_traits::{MulAdd, Num};

use crate::{AlignedArray, Ring};

/// Single-Input-Single-Output, Finite Impulse Response filter.
/// This is simply a running convolution of the taps with the samples.
#[derive(Clone, Copy)]
pub struct SisoFirFilter<const ORDER: usize, T: Num + Copy + MulAdd<Output = T>> {
    /// Latest output
    y: T,
    /// Internal sample buffer
    x: Ring<T, ORDER>,
    /// Filter taps ordered most-recent-last
    taps: AlignedArray<T, ORDER>,
}

impl<const ORDER: usize, T: Num + Copy + MulAdd<Output = T>> SisoFirFilter<ORDER, T> {
    /// Evaluate the next estimated value based on the latest measurement
    /// in 2N-1 floating-point ops for a filter of order N.
    /// This is a simple convolution - push the latest value, then multiply-and-sum.
    #[inline]
    pub fn update(&mut self, u: T) -> T {
        self.x.push(u);
        self.y = self.taps.dot(&self.x, T::zero());
        self.y
    }

    /// Populate a new filter with arbitrary taps.
    /// Filter taps are ordered most-recent-last.
    pub fn new(taps: &[T]) -> Self {
        let mut taps_ = [T::zero(); ORDER];
        taps_.copy_from_slice(taps);

        Self {
            y: T::zero(),
            x: Ring::new(T::zero()),
            taps: AlignedArray(taps_),
        }
    }

    /// Initialize filter internal state to the steady value
    /// achieved for input `u`. For filters with unity steady-state gain,
    /// this will also produce an output reading of `u`.
    pub fn initialize(&mut self, u: T) {
        self.x = Ring::new(u);
        self.update(u);
    }

    /// Read-only access to taps.
    /// This is, equivalently, the one nontrivial row of either the state-space `A` or `C`
    /// matrix depending on choice of formulation.
    pub fn taps(&self) -> &[T; ORDER] {
        &self.taps.0
    }

    /// Latest output
    pub fn y(&self) -> T {
        self.y
    }

    /// Read-only access to internal state buffer
    pub fn x(&self) -> &Ring<T, ORDER> {
        &self.x
    }
}