lasprs 0.14.1

Library for Acoustic Signal Processing (Rust edition, with optional Python bindings via pyo3)
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Configuration of module. Here, we can choose to compile for 32-bits or
//! 64-bit floating point values as basic data storage and computation size.
//! Default is f64.
//!
//!
//!
use pkg_version::{pkg_version_major, pkg_version_minor};
use std::ops::Deref;
use std::time::Duration;

/// Major version of lasprs
pub const LASP_VERSION_MAJOR: u32 = pkg_version_major! {};

/// Minor version of lasprs
pub const LASP_VERSION_MINOR: u32 = pkg_version_minor! {};

/// Library name of this library
pub const LIB_NAME: &str = "lasprs";

/// File extension for measurement files
pub const MEASUREMENT_EXTENSION: &str = "h5";

/// Duration of the pre-capture buffer when measuring sound levels. This is
/// required for the filter run-in time of the slowest filters, think of the
/// Slow time weighting, and / or the 8 Hz octave band filter.
pub(crate) const PRECAP_DURATION: Duration = Duration::from_secs(3);

/// Maximum number of channels for a device of measurement supported by LaspRs.
#[expect(dead_code)]
pub(crate) const MAX_CHANNELS: usize = 64;

/// Storage for allocating channel info on the stack (in a SmallVec).
pub(crate) const TYPICAL_CHANNELS: usize = 8;

/// Fraction of the time weighting time constant that determines the sample
/// spacing of the levels-vs-time output of the SLM.
pub(crate) const SLM_LT_DECIMATION_FRACTION: Flt = 0.1;

cfg_select! {
  all(any(feature="f64",target_pointer_width = "64"), not(feature="f32"))=> {
        /// Floating-point value, compile time option to make it either f32, or
        /// f64.
        pub type Flt = f64;

        /// Ratio between circumference and diameter of a circle
        pub const pi: Flt = std::f64::consts::PI;

        /// Square root of 2
        pub const sq2: Flt = std::f64::consts::SQRT_2;

        /// Postive infinity
        pub const FltInf: Flt = f64::INFINITY;

    }
    all(any(feature="f32", target_pointer_width = "32"), not(feature="f64")) =>{
        /// Floating-point value, compile time option to make it either f32, or
        /// f64
        pub type Flt = f32;

        /// Ratio between circumference and diameter of a circle
        pub const pi: Flt = std::f32::consts::PI;

        /// Square root of 2
        pub const sq2: Flt = std::f32::consts::SQRT_2;

        /// Postive infinity
        pub const FltInf: Flt = f32::INFINITY;
    }
    _ => {
        std::compile_error!("feature should be f32 or f64");
    }
}

/// Ratio between circumference and diameter of a circle
pub const twopi: Flt = pi * 2.;

cfg_select! {
    any(feature = "python-bindings")=> {
        pub(crate) use numpy::{IntoPyArray,PyArray, PyArray1, PyArray2, PyArray3, PyArrayDyn, PyArrayLike1,
            PyArrayLike2,PyArrayLike3,PyReadonlyArrayDyn,PyReadonlyArray1, convert::ToPyArray};

        pub(crate) use pyo3::prelude::*;
        pub(crate) use pyo3::exceptions::PyValueError;
        pub(crate) use pyo3::{pymodule, types::PyModule, PyResult};

        pub(crate) use pyo3_stub_gen::derive::*;
        pub(crate) use pyo3_stub_gen::*;
        pub(crate) use pyo3::types::IntoPyDict;
        pub(crate) use pyo3::exceptions::PyException;
    }
    _ => {}
}

pub use ndarray::prelude::*;
pub use ndarray::{Array1, Array2, ArrayView1, ArrayViewMut1};

pub use ndarray::Zip;
use num::complex::Complex;
pub use num::complex::ComplexFloat;
use serde::{Deserialize, Serialize};

/// View into 1D array of floats
pub type VdView<'a> = ArrayView1<'a, Flt>;

/// View into 1D array of complex floats
pub type VcView<'a> = ArrayView1<'a, Cflt>;

/// Complex number floating point
pub type Cflt = Complex<Flt>;

/// Complex unit sqrt(-1)
pub const I: Cflt = Cflt::new(0., 1.);

/// Complex 0
pub const C0: Cflt = Cflt::new(0., 0.);

/// (Owning) Vector of floating point values
pub type Vd = Vec<Flt>;

/// (Owning) Vector of complex floating point values
pub type Vc = Vec<Cflt>;

/// 1D array of floats
pub type Dcol = Array1<Flt>;

/// 1D array of complex floats
pub type Ccol = Array1<Cflt>;

/// 2D array of floats
pub type Dmat = Array2<Flt>;

/// 2D array of complex floats
pub type Cmat = Array2<Cflt>;

cfg_select! {
    any(feature = "python-bindings") => {
        /// 1D array of T as returned from Rust to Numpy
        pub type PyArr1<'py, T> = Bound<'py, PyArray<T, ndarray::Dim<[usize; 1]>>>;

        /// 1D array Floats returned from Rust to Numpy
        pub type PyArr1Flt<'py> = PyArr1<'py, Flt>;

        /// 1D array of Complex returned from Rust to Numpy
        pub type PyArr1Cflt<'py> = PyArr1<'py, Cflt>;
   }
   _ => {}
}