lasprs 0.4.1

Library for Acoustic Signal Processing (Rust edition, with optional Python bindings via pyo3)
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

//! Contains filter implemententations for [Biquad]s, series of
//! biquads ([SeriesBiquad]) and banks of series of biquads ([BiquadBank]).
//!
//! Contains [Biquad], [SeriesBiquad], and [BiquadBank]. These are all constructs that work on
//! blocks of input data, and apply filters on it. TODO: implement FIR filter.
#![allow(non_snake_case)]
use super::config::*;

mod biquad;
mod biquadbank;
mod dummy;
mod seriesbiquad;

pub use biquad::Biquad;
pub use biquadbank::BiquadBank;
pub use dummy::DummyFilter;
pub use seriesbiquad::SeriesBiquad;

/// Implementations of this trait are able to DSP-filter input data.
pub trait Filter: Send {
    //! The filter trait is implemented by, for example, [Biquad], [SeriesBiquad], and [BiquadBank].

    /// Filter input to generate output. A vector of output floats is generated with the same
    /// length as input.
    fn filter(&mut self, input: &[Flt]) -> Vd;
    /// Reset the filter state(s). In essence, this makes sure that all memory of the past is
    /// forgotten.
    fn reset(&mut self);

    /// Required method for cloning a BiquadBank, such that arbitrary filter types can be used as
    /// their 'channels'.
    fn clone_dyn(&self) -> Box<dyn Filter>;
}

/// Implementations are able to generate transfer functions of itself

pub trait TransferFunction<'a, T>: Send
where
    T: AsArray<'a, Flt>,
{
    /// Compute frequency response (i.e. transfer function from input to output)
    ///
    /// # Args
    ///
    /// * `freq` - The frequency in [Hz]
    ///
    /// # Returns
    ///
    /// The transfer function: A column vector with the frequency response for
    /// each frequency in `freq`.
    ///
    fn tf(&self, fs: Flt, freq: T) -> Ccol;
}

impl Clone for Box<dyn Filter> {
    fn clone(&self) -> Self {
        self.clone_dyn()
    }
}