spectrum_analyzer/

spectrum.rs

/*
MIT License

Copyright (c) 2023 Philipp Schuster

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
//! Module for the struct [`FrequencySpectrum`].

use self::math::*;
use crate::error::SpectrumAnalyzerError;
use crate::frequency::{Frequency, FrequencyValue};
use crate::scaling::{SpectrumDataStats, SpectrumScalingFunction};
use alloc::vec::Vec;

/// Convenient wrapper around the processed FFT result.
///
/// This is the result produced by [`samples_fft_to_spectrum`]. It describes
/// each frequency and its corresponding value (magnitude) from the analyzed
/// samples, according to the provided input parameters. The data is
/// scaled/normalized according to the optionally applied scaling function.
///
/// Unless frequencies were explicitly excluded, the spectrum covers the full
/// range from the DC component (0 Hz) up to the Nyquist frequency with the
/// frequency resolution derived from the input data.
///
/// [`samples_fft_to_spectrum`]: crate::samples_fft_to_spectrum
#[derive(Debug)]
pub struct FrequencySpectrum {
    /// All (Frequency, FrequencyValue) data pairs sorted from lowest to highest
    /// frequency (in Hz).
    ///
    /// The frequency bin refers to the original frequency bin and not
    /// necessarily to the element in the vector, if there was a
    /// [`FrequencyLimit`].
    ///
    /// The data is normalized/scaled according to all applied scaling
    /// functions.
    ///
    /// [`FrequencyLimit`]: crate::limit::FrequencyLimit
    data: Vec<(Frequency, FrequencyValue)>,
    /// Frequency resolution of the examined samples in Hertz, i.e. the
    /// frequency steps between elements in [`Self::data()`].
    frequency_resolution: Frequency,
    /// Number of samples that were analyzed. Might be higher than the length
    /// of `data`, if the spectrum was created with a [`FrequencyLimit`].
    ///
    /// [`FrequencyLimit`]: crate::limit::FrequencyLimit
    samples_len: u32,
    /// Average frequency value corresponding to data in
    /// [`FrequencySpectrum::data()`].
    average: FrequencyValue,
    /// Minimal element in [`FrequencySpectrum::data()`] regarding the
    /// frequency value.
    min: (Frequency, FrequencyValue),
    /// Maximal element in [`FrequencySpectrum::data()`] regarding the
    /// frequency value.
    max: (Frequency, FrequencyValue),
}

impl FrequencySpectrum {
    /// Creates a new object. Calculates several metrics from the data
    /// in the given vector.
    ///
    /// ## Parameters
    /// * `data` Vector with all ([`Frequency`], [`FrequencyValue`])-tuples
    /// * `frequency_resolution` Resolution in Hertz. This equals to
    ///   `data[1].0 - data[0].0`.
    /// * `samples_len` Number of samples. Might be bigger than `data.len()`
    ///   if the spectrum is obtained with a frequency limit.
    #[inline]
    #[must_use]
    pub(crate) fn new(
        data: Vec<(Frequency, FrequencyValue)>,
        frequency_resolution: Frequency,
        samples_len: u32,
    ) -> Self {
        debug_assert!(
            data.len() >= 2,
            "Input data of length={} for spectrum makes no sense!",
            data.len()
        );

        let mut obj = Self {
            data,
            frequency_resolution,
            samples_len,
            // placeholders; calc_statistics() below fills them in
            average: FrequencyValue::default(),
            min: (Frequency::default(), FrequencyValue::default()),
            max: (Frequency::default(), FrequencyValue::default()),
        };

        // Important to call this once initially.
        obj.calc_statistics();
        obj
    }

    /// Applies the function `scaling_fn` to each element and updates several
    /// metrics about the spectrum, such as `min` and `max`, afterwards
    /// accordingly. It ensures that no value is `NaN` or `Infinity`
    /// (regarding IEEE-754) after `scaling_fn` was applied. Otherwise,
    /// `SpectrumAnalyzerError::ScalingError` is returned.
    ///
    /// ## Parameters
    /// * `scaling_fn` See [`SpectrumScalingFunction`].
    #[inline]
    pub fn apply_scaling_fn(
        &mut self,
        scaling_fn: &SpectrumScalingFunction,
    ) -> Result<(), SpectrumAnalyzerError> {
        // This represents statistics about the spectrum in its current state
        // which a scaling function may use to scale values.
        //
        // On the first invocation of this function, these values represent the
        // statistics for the unscaled, hence initial, spectrum.
        let stats = SpectrumDataStats {
            min: self.min.1,
            max: self.max.1,
            average: self.average,
            // attention! not necessarily `data.len()`!
            n: self.samples_len as f32,
        };

        for (_fr, fr_val) in &mut self.data {
            // scale value
            let scaled_val: f32 = scaling_fn(fr_val.val(), &stats);

            // sanity check
            if scaled_val.is_nan() || scaled_val.is_infinite() {
                return Err(SpectrumAnalyzerError::ScalingError(
                    fr_val.val(),
                    scaled_val,
                ));
            }

            // Update value in spectrum
            *fr_val = scaled_val.into()
        }

        self.calc_statistics();
        Ok(())
    }

    /// Returns the average frequency value of the spectrum.
    #[inline]
    #[must_use]
    pub const fn average(&self) -> FrequencyValue {
        self.average
    }

    /// Returns the maximum (frequency, frequency value)-pair of the spectrum
    /// **regarding the frequency value**.
    #[inline]
    #[must_use]
    pub const fn max(&self) -> (Frequency, FrequencyValue) {
        self.max
    }

    /// Returns the minimum (frequency, frequency value)-pair of the spectrum
    /// **regarding the frequency value**.
    #[inline]
    #[must_use]
    pub const fn min(&self) -> (Frequency, FrequencyValue) {
        self.min
    }

    /// Returns <code>[FrequencySpectrum::max()].1</code> subtracted by
    /// <code>[FrequencySpectrum::min()].1</code>, i.e. the range of the
    /// frequency values (not the frequencies itself, but their values).
    #[inline]
    #[must_use]
    pub fn range(&self) -> FrequencyValue {
        self.max().1 - self.min().1
    }

    /// Returns the underlying sorted data.
    #[inline]
    #[must_use]
    #[allow(clippy::missing_const_for_fn)] // false positive
    pub fn data(&self) -> &[(Frequency, FrequencyValue)] {
        debug_assert!(self.data.is_sorted());
        &self.data
    }

    /// Returns the frequency resolution of this spectrum.
    #[inline]
    #[must_use]
    pub const fn frequency_resolution(&self) -> Frequency {
        self.frequency_resolution
    }

    /// Returns the number of samples used to obtain this spectrum.
    #[inline]
    #[must_use]
    pub const fn samples_len(&self) -> u32 {
        self.samples_len
    }

    /// Getter for the highest frequency that is captured inside this spectrum.
    /// Shortcut for `spectrum.data()[spectrum.data().len() - 1].0`.
    /// This corresponds to the [`crate::limit::FrequencyLimit`] of the spectrum.
    ///
    /// This method could return the Nyquist frequency, if there was no Frequency
    /// limit while obtaining the spectrum.
    #[inline]
    #[must_use]
    pub fn max_fr(&self) -> Frequency {
        self.data[self.data.len() - 1].0
    }

    /// Getter for the lowest frequency that is captured inside this spectrum.
    /// Shortcut for `spectrum.data()[0].0`.
    /// This corresponds to the [`crate::limit::FrequencyLimit`] of the spectrum.
    ///
    /// This method could return the DC component, see [`Self::dc_component`].
    #[inline]
    #[must_use]
    pub fn min_fr(&self) -> Frequency {
        self.data[0].0
    }

    /// Returns the *DC Component* or also called *DC bias* which corresponds
    /// to the FFT result at index 0 which corresponds to `0Hz`. This is only
    /// present if the frequencies were not limited to for example `100 <= f <= 10000`
    /// when the libraries main function was called.
    ///
    /// Note that the unscaled value is `N` times the mean of the (windowed)
    /// samples, not the mean itself. See [`crate::samples_fft_to_spectrum`].
    ///
    /// More information:
    /// <https://dsp.stackexchange.com/questions/12972/discrete-fourier-transform-what-is-the-dc-term-really>
    ///
    /// Excerpt:
    /// *As far as practical applications go, the DC or 0 Hz term is not particularly useful.
    /// In many cases it will be close to zero, as most signal processing applications will
    /// tend to filter out any DC component at the analogue level. In cases where you might
    /// be interested it can be calculated directly as an average in the usual way, without
    /// resorting to a DFT/FFT.* - Paul R.
    #[inline]
    #[must_use]
    pub fn dc_component(&self) -> Option<FrequencyValue> {
        let (maybe_dc_component, dc_value) = &self.data[0];
        if *maybe_dc_component == 0.0 {
            Some(*dc_value)
        } else {
            None
        }
    }

    /// Returns the value of the given frequency from the spectrum either
    /// exactly or approximated.
    ///
    /// If the value is out of bounds, the function returns `None`.
    ///
    /// If `search_fr` is not exactly given in the spectrum, i.e. due to the
    /// [`Self::frequency_resolution`], this function takes the two closest
    /// neighbors/points (A, B), put a linear function through them and calculates
    /// the point C in the middle. This is done by the private function
    /// `calculate_y_coord_between_points`.
    ///
    /// The interpolated value only follows the shape of the spectrum. It is
    /// not the value a sine wave of exactly `search_fr` would have, because
    /// such a sine wave leaks into the neighboring bins.
    ///
    /// ## Parameters
    /// - `search_fr` The frequency of that you want the value in the spectrum.
    #[inline]
    #[must_use]
    pub fn freq_val_exact(&self, search_fr: f32) -> Option<FrequencyValue> {
        // lowest frequency in the spectrum
        let (min_fr, min_fr_val) = self.data[0];
        // highest frequency in the spectrum
        let (max_fr, max_fr_val) = self.data[self.data.len() - 1];

        // https://docs.rs/float-cmp/0.8.0/float_cmp/
        let equals_min_fr = float_cmp::approx_eq!(f32, min_fr.val(), search_fr, ulps = 3);
        let equals_max_fr = float_cmp::approx_eq!(f32, max_fr.val(), search_fr, ulps = 3);

        // Fast return if possible
        if equals_min_fr {
            return Some(min_fr_val);
        }
        if equals_max_fr {
            return Some(max_fr_val);
        }
        // bounds check; a NaN search frequency fails every comparison and
        // therefore lands here as well
        let in_bounds = search_fr >= min_fr && search_fr <= max_fr;
        if !in_bounds {
            return None;
        }

        // We search for Point C (x=search_fr, y=???) between Point A and Point B iteratively.
        // Point B is always the successor of A.

        for two_points in self.data.iter().as_slice().windows(2) {
            let point_a = two_points[0];
            let point_b = two_points[1];
            let point_a_x = point_a.0.val();
            let point_a_y = point_a.1;
            let point_b_x = point_b.0.val();
            let point_b_y = point_b.1.val();

            // check if we are in the correct window; we are in the correct window
            // iff point_a_x <= search_fr <= point_b_x
            if search_fr > point_b_x {
                continue;
            }

            let fr_val = if float_cmp::approx_eq!(f32, point_a_x, search_fr, ulps = 3) {
                // directly return if possible
                point_a_y
            } else {
                calculate_y_coord_between_points(
                    (point_a_x, point_a_y.val()),
                    (point_b_x, point_b_y),
                    search_fr,
                )
                .into()
            };
            return Some(fr_val);
        }

        unreachable!("the loop always terminates");
    }

    /// Returns the frequency closest to parameter `search_fr` in the spectrum.
    ///
    /// If the value is out of bounds, the function returns `None`.
    ///
    /// For example, if the spectrum looks like this:
    /// ```text
    /// Vector:    [0]      [1]      [2]      [3]
    /// Frequency  100 Hz   200 Hz   300 Hz   400 Hz
    /// Fr Value   0.0      1.0      0.5      0.1
    /// ```
    /// then `get_frequency_value_closest(320)` will return `(300.0, 0.5)`.
    ///
    /// ## Parameters
    /// - `search_fr` The frequency of that you want the value in the spectrum.
    #[inline]
    #[must_use]
    pub fn freq_val_closest(&self, search_fr: f32) -> Option<(Frequency, FrequencyValue)> {
        // lowest frequency in the spectrum
        let (min_fr, min_fr_val) = self.data[0];
        // highest frequency in the spectrum
        let (max_fr, max_fr_val) = self.data[self.data.len() - 1];

        // https://docs.rs/float-cmp/0.8.0/float_cmp/
        let equals_min_fr = float_cmp::approx_eq!(f32, min_fr.val(), search_fr, ulps = 3);
        let equals_max_fr = float_cmp::approx_eq!(f32, max_fr.val(), search_fr, ulps = 3);

        // Fast return if possible
        if equals_min_fr {
            return Some((min_fr, min_fr_val));
        }
        if equals_max_fr {
            return Some((max_fr, max_fr_val));
        }

        // bounds check; a NaN search frequency fails every comparison and
        // therefore lands here as well
        let in_bounds = search_fr >= min_fr && search_fr <= max_fr;
        if !in_bounds {
            return None;
        }

        for two_points in self.data.iter().as_slice().windows(2) {
            let point_a = two_points[0];
            let point_b = two_points[1];
            let point_a_x = point_a.0;
            let point_a_y = point_a.1;
            let point_b_x = point_b.0;
            let point_b_y = point_b.1;

            // check if we are in the correct window; we are in the correct window
            // iff point_a_x <= search_fr <= point_b_x
            if search_fr > point_b_x {
                continue;
            }

            let pair = if float_cmp::approx_eq!(f32, point_a_x.val(), search_fr, ulps = 3) {
                // directly return if possible
                (point_a_x, point_a_y)
            } else {
                // absolute difference
                let delta_to_a = search_fr - point_a_x;
                if delta_to_a / self.frequency_resolution < 0.5 {
                    (point_a_x, point_a_y)
                } else {
                    (point_b_x, point_b_y)
                }
            };
            return Some(pair);
        }

        unreachable!("the loop always terminates");
    }

    /// Returns a sorted [`Vec`] with all value pairs as `f32`.
    #[inline]
    #[must_use]
    pub fn to_vec(&self) -> Vec<(f32, f32)> {
        debug_assert!(self.data.is_sorted());
        self.data
            .iter()
            .map(|(fr, fr_val)| (fr.val(), fr_val.val()))
            .collect()
    }

    /// Calculates the `min`, `max`, and `average` of the frequency values.
    #[inline]
    fn calc_statistics(&mut self) {
        // Single pass over the data: min, max, and sum (for the average).
        //
        // On equal frequency values, min keeps the first and max the last
        // occurrence, so results are deterministic.
        let mut min = self.data[0];
        let mut max = self.data[0];
        let mut sum = 0.0;
        for pair in &self.data {
            if pair.1 < min.1 {
                min = *pair;
            }
            if pair.1 >= max.1 {
                max = *pair;
            }
            sum += pair.1.val();
        }

        // average of all frequency values
        let average: FrequencyValue = (sum / self.data.len() as f32).into();

        // check that I get the comparison right (and not from max to min)
        debug_assert!(min.1 <= max.1, "min must be <= max");

        self.min = min;
        self.max = max;
        self.average = average;
    }
}

/*impl FromIterator<(Frequency, FrequencyValue)> for FrequencySpectrum {

    #[inline]
    fn from_iter<T: IntoIterator<Item=(Frequency, FrequencyValue)>>(iter: T) -> Self {
        // 1024 is just a guess: most likely 2048 is a common FFT length,
        // i.e. 1024 results for the frequency spectrum.
        let mut vec = Vec::with_capacity(1024);
        for (fr, val) in iter {
            vec.push((fr, val))
        }

        FrequencySpectrum::new(vec)
    }
}*/

mod math {
    // use super::*;

    /// Calculates the y coordinate of Point C between two given points A and B
    /// if the x-coordinate of C is known. It does that by putting a linear function
    /// through the two given points.
    ///
    /// ## Parameters
    /// - `(x1, y1)` x and y of point A
    /// - `(x2, y2)` x and y of point B
    /// - `x_coord` x coordinate of searched point C
    ///
    /// ## Return Value
    /// y coordinate of searched point C
    #[inline]
    pub fn calculate_y_coord_between_points(
        (x1, y1): (f32, f32),
        (x2, y2): (f32, f32),
        x_coord: f32,
    ) -> f32 {
        // e.g. Points (100, 1.0) and (200, 0.0)
        // y=f(x)=-0.01x + c
        // 1.0 = f(100) = -0.01x + c
        // c = 1.0 + 0.01*100 = 2.0
        // y=f(180)=-0.01*180 + 2.0

        // gradient, anstieg
        let slope = (y2 - y1) / (x2 - x1);
        // calculate c in y=f(x)=slope * x + c
        let c = y1 - slope * x1;

        slope * x_coord + c
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn test_calculate_y_coord_between_points() {
            assert_eq!(
                // expected y coordinate
                0.5,
                calculate_y_coord_between_points((100.0, 1.0), (200.0, 0.0), 150.0,),
                "Must calculate middle point between points by laying a linear function through the two points"
            );
            // Must calculate arbitrary point between points by laying a linear function through the
            // two points.
            float_cmp::assert_approx_eq!(
                f32,
                0.2,
                calculate_y_coord_between_points((100.0, 1.0), (200.0, 0.0), 180.0,),
                ulps = 3
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Test if a frequency spectrum can be sent to other threads.
    #[test]
    const fn test_impl_send() {
        #[allow(unused)]
        // test if this compiles
        fn consume(s: FrequencySpectrum) {
            let _: &dyn Send = &s;
        }
    }

    #[test]
    fn test_freq_val_invalid_search_frequency() {
        let spectrum_vector = vec![
            (0.0_f32.into(), 5.0_f32.into()),
            (450.0.into(), 200.0.into()),
        ];
        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            50.0.into(),
            spectrum_vector.len() as _,
        );

        for search_fr in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -1.0, 451.0] {
            assert_eq!(None, spectrum.freq_val_exact(search_fr));
            assert_eq!(None, spectrum.freq_val_closest(search_fr));
        }
    }

    #[test]
    #[allow(clippy::cognitive_complexity)]
    fn test_spectrum_basic() {
        let spectrum = vec![
            (0.0_f32, 5.0_f32),
            (50.0, 50.0),
            (100.0, 100.0),
            (150.0, 150.0),
            (200.0, 100.0),
            (250.0, 20.0),
            (300.0, 0.0),
            (450.0, 200.0),
            (500.0, 100.0),
        ];

        let spectrum_vector = spectrum
            .into_iter()
            .map(|(fr, val)| (fr.into(), val.into()))
            .collect::<Vec<(Frequency, FrequencyValue)>>();

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            50.0.into(),
            spectrum_vector.len() as _,
        );

        // test inner vector is ordered
        {
            assert_eq!(
                (0.0.into(), 5.0.into()),
                spectrum.data()[0],
                "Vector must be ordered"
            );
            assert_eq!(
                (50.0.into(), 50.0.into()),
                spectrum.data()[1],
                "Vector must be ordered"
            );
            assert_eq!(
                (100.0.into(), 100.0.into()),
                spectrum.data()[2],
                "Vector must be ordered"
            );
            assert_eq!(
                (150.0.into(), 150.0.into()),
                spectrum.data()[3],
                "Vector must be ordered"
            );
            assert_eq!(
                (200.0.into(), 100.0.into()),
                spectrum.data()[4],
                "Vector must be ordered"
            );
            assert_eq!(
                (250.0.into(), 20.0.into()),
                spectrum.data()[5],
                "Vector must be ordered"
            );
            assert_eq!(
                (300.0.into(), 0.0.into()),
                spectrum.data()[6],
                "Vector must be ordered"
            );
            assert_eq!(
                (450.0.into(), 200.0.into()),
                spectrum.data()[7],
                "Vector must be ordered"
            );
            assert_eq!(
                (500.0.into(), 100.0.into()),
                spectrum.data()[8],
                "Vector must be ordered"
            );
        }

        // test DC component getter
        assert_eq!(
            Some(5.0.into()),
            spectrum.dc_component(),
            "Spectrum must contain DC component"
        );

        // test getters
        {
            assert_eq!(0.0, spectrum.min_fr(), "min_fr() must work");
            assert_eq!(500.0, spectrum.max_fr(), "max_fr() must work");
            assert_eq!(
                (300.0.into(), 0.0.into()),
                spectrum.min(),
                "min() must work"
            );
            assert_eq!(
                (450.0.into(), 200.0.into()),
                spectrum.max(),
                "max() must work"
            );
            assert_eq!(200.0 - 0.0, spectrum.range(), "range() must work");
            assert_eq!(80.55556, spectrum.average(), "average() must work");
            assert_eq!(
                50.0,
                spectrum.frequency_resolution(),
                "frequency resolution must be returned"
            );
        }

        // test get frequency exact
        {
            assert_eq!(5.0, spectrum.freq_val_exact(0.0).unwrap(),);
            assert_eq!(50.0, spectrum.freq_val_exact(50.0).unwrap(),);
            assert_eq!(150.0, spectrum.freq_val_exact(150.0).unwrap(),);
            assert_eq!(100.0, spectrum.freq_val_exact(200.0).unwrap(),);
            assert_eq!(20.0, spectrum.freq_val_exact(250.0).unwrap(),);
            assert_eq!(0.0, spectrum.freq_val_exact(300.0).unwrap(),);
            assert_eq!(100.0, spectrum.freq_val_exact(375.0).unwrap(),);
            assert_eq!(200.0, spectrum.freq_val_exact(450.0).unwrap(),);
            assert_eq!(None, spectrum.freq_val_exact(2000.0));
        }

        // test get frequency closest
        {
            assert_eq!(
                (0.0.into(), 5.0.into()),
                spectrum.freq_val_closest(0.0).unwrap()
            );
            assert_eq!(
                (50.0.into(), 50.0.into()),
                spectrum.freq_val_closest(50.0).unwrap()
            );
            assert_eq!(
                (450.0.into(), 200.0.into()),
                spectrum.freq_val_closest(450.0).unwrap()
            );
            assert_eq!(
                (450.0.into(), 200.0.into()),
                spectrum.freq_val_closest(448.0).unwrap()
            );
            assert_eq!(
                (450.0.into(), 200.0.into()),
                spectrum.freq_val_closest(400.0).unwrap()
            );
            assert_eq!(
                (50.0.into(), 50.0.into()),
                spectrum.freq_val_closest(47.3).unwrap()
            );
            assert_eq!(
                (50.0.into(), 50.0.into()),
                spectrum.freq_val_closest(51.3).unwrap()
            );
        }
    }

    #[test]
    fn test_spectrum_get_frequency_value_exact_below_min_return_none() {
        let spectrum_vector = vec![
            (0.0_f32.into(), 5.0_f32.into()),
            (450.0.into(), 200.0.into()),
        ];

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            50.0.into(),
            spectrum_vector.len() as _,
        );

        // -1 not included
        assert!(spectrum.freq_val_exact(-1.0).is_none());
    }

    #[test]
    fn test_spectrum_get_frequency_value_exact_below_max_return_none() {
        let spectrum_vector = vec![
            (0.0_f32.into(), 5.0_f32.into()),
            (450.0.into(), 200.0.into()),
        ];

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            50.0.into(),
            spectrum_vector.len() as _,
        );

        // 451 not included
        assert!(spectrum.freq_val_exact(451.0).is_none());
    }

    #[test]
    fn test_nan_safety() {
        let spectrum_vector: Vec<(Frequency, FrequencyValue)> = vec![(0.0.into(), 0.0.into()); 8];

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            // not important here, any value
            50.0.into(),
            spectrum_vector.len() as _,
        );

        assert_ne!(f32::NAN, spectrum.min().1, "NaN is not valid, must be 0.0!");
        assert_ne!(f32::NAN, spectrum.max().1, "NaN is not valid, must be 0.0!");
        assert_ne!(
            f32::NAN,
            spectrum.average(),
            "NaN is not valid, must be 0.0!"
        );

        assert_ne!(
            f32::INFINITY,
            spectrum.min().1,
            "INFINITY is not valid, must be 0.0!"
        );
        assert_ne!(
            f32::INFINITY,
            spectrum.max().1,
            "INFINITY is not valid, must be 0.0!"
        );
        assert_ne!(
            f32::INFINITY,
            spectrum.average(),
            "INFINITY is not valid, must be 0.0!"
        );
    }

    #[test]
    fn test_no_dc_component() {
        let spectrum_vector: Vec<(Frequency, FrequencyValue)> =
            vec![(150.0.into(), 150.0.into()), (200.0.into(), 100.0.into())];

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            50.0.into(),
            spectrum_vector.len() as _,
        );

        assert!(
            spectrum.dc_component().is_none(),
            "This spectrum should not contain a DC component!"
        )
    }

    #[test]
    fn test_max() {
        let maximum: (Frequency, FrequencyValue) = (34.991455.into(), 86.791145.into());
        let spectrum_vector: Vec<(Frequency, FrequencyValue)> = vec![
            (2.6916504.into(), 22.81816.into()),
            (5.383301.into(), 2.1004658.into()),
            (8.074951.into(), 8.704016.into()),
            (10.766602.into(), 3.4043686.into()),
            (13.458252.into(), 8.649045.into()),
            (16.149902.into(), 9.210494.into()),
            (18.841553.into(), 14.937911.into()),
            (21.533203.into(), 5.1524887.into()),
            (24.224854.into(), 20.706167.into()),
            (26.916504.into(), 8.359295.into()),
            (29.608154.into(), 3.7514696.into()),
            (32.299805.into(), 15.109907.into()),
            maximum,
            (37.683105.into(), 52.140736.into()),
            (40.374756.into(), 24.108875.into()),
            (43.066406.into(), 11.070151.into()),
            (45.758057.into(), 10.569871.into()),
            (48.449707.into(), 6.1969466.into()),
            (51.141357.into(), 16.722788.into()),
            (53.833008.into(), 8.93011.into()),
        ];

        let spectrum = FrequencySpectrum::new(
            spectrum_vector.clone(),
            44100.0.into(),
            spectrum_vector.len() as _,
        );

        assert_eq!(
            spectrum.max(),
            maximum,
            "Should return the maximum frequency value!"
        )
    }
}