Digital Signal Processing¶

Comprehensive DSP algorithms including filters, oscillators, and signal analysis tools.

A¶

variable biquad_section<T>::a0 Denominator coefficient z^0
variable biquad_section<T>::a1 Denominator coefficient z^-1
variable iir_params<T, filters>::a1 Denominator coefficient z^-1 per section.
variable biquad_section<T>::a2 Denominator coefficient z^-2
variable iir_params<T, filters>::a2 Denominator coefficient z^-2 per section.
function amp_to_dB(const T1 &) Convert an amplitude value to decibels (20*log10).
function amp_to_dB(E1 &&) Convert an amplitude expression to decibels (20*log10).
variable expression_window_with_metrics<T, metrics>::arg
typedef expression_delay<delay, E, stateless, STag>::ArgTraits
typedef expression_delay<1, E, stateless, STag>::ArgTraits
enum constant speaker_arrangement::Arr102 L, R, C, Lfe, Ls, Rs, Lc, Rc, Tfl, Tfr, Trl, Trr (10.2).
enum constant speaker_arrangement::Arr50 L, R, C, Ls, Rs (5.0).
enum constant speaker_arrangement::Arr51 L, R, C, Lfe, Ls, Rs (5.1).
function arrangement_for_channels(size_t) Returns a predefined speaker arrangement for a given number of channels.
function arrangement_speakers(speaker_arrangement) Returns the canonical channel list for a speaker arrangement.
function aweighting(const T1 &) A-weighting filter response for a scalar frequency.
function aweighting(E1 &&) A-weighting filter response as an expression.

B¶

variable biquad_section<T>::b0 Numerator coefficient z^0
variable iir_params<T, filters>::b0 Numerator coefficient z^0 per section.
variable biquad_section<T>::b1 Numerator coefficient z^-1
variable iir_params<T, filters>::b1 Numerator coefficient z^-1 per section.
variable biquad_section<T>::b2 Numerator coefficient z^-2
variable iir_params<T, filters>::b2 Numerator coefficient z^-2 per section.
enum constant biquad_type::bandpass Passes frequencies inside a band.
enum constant biquad_type::bandstop Rejects frequencies inside a band.
enum constant window_type::bartlett
enum constant window_type::bartlett_hann
typedef iir_params<T, tag_dynamic_vector>::base
function begin_pass(const expression_iir<1, T, E1, Stateless> &, shape<1>, shape<1>) Internal ADL-provided implementation for
function begin_pass(const expression_iir<filters, T, E1, Stateless> &, shape<1>, shape<1>) Internal ADL-provided implementation for
function bessel(int) Analog Bessel/Thomson lowpass filter prototype (normalized cutoff = 1 rad/s).
function biquad_allpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the all-pass biquad filter
function biquad_bandpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the band-pass biquad filter
function biquad_highpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-pass biquad filter
function biquad_highshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-shelf biquad filter
function biquad_lowpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-pass biquad filter
function biquad_lowshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-shelf biquad filter
function biquad_notch(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the notch biquad filter
function biquad_peak(std::type_identity_t<T>, std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the peak biquad filter
class biquad_section<T> Structure for holding biquad filter coefficients.
constructor biquad_section<T>::biquad_section<T>() Default constructor: produces a pass-through section (a0=b0=1, rest 0).
function biquad_section<T>::biquad_section<T>(const biquad_section<U> &) Converting copy constructor.
constructor biquad_section<T>::biquad_section<T>(T, T, T, T, T, T) Construct from explicit coefficient values.
class biquad_state<T, filters> Per-section delay-line state for a cascade of filters biquad sections.
constructor biquad_state<T, filters>::biquad_state<T, filters>() Default constructor: zero-initializes all registers.
enum biquad_type Type of biquad filter response used by coefficient design helpers.
enum constant window_type::blackman
enum constant window_type::blackman_harris
variable iir_state<T, filters>::block_end End index of the current processing block.
enum constant window_type::bohman
function butterworth(int) Analog Butterworth lowpass filter prototype (normalized cutoff = 1 rad/s).
function bweighting(const T1 &) B-weighting filter response for a scalar frequency.
function bweighting(E1 &&) B-weighting filter response as an expression.

C¶

enum constant speaker_type::C Alias for Center.
function window_linspace<T>::calc_p2(size_t, bool)
function window_linspace<T>::calc_p(size_t, bool)
enum constant speaker_type::Center Front center.
function chebyshev1(int, double) Analog Chebyshev Type I lowpass filter prototype (normalized cutoff = 1 rad/s).
function chebyshev2(int, double) Analog Chebyshev Type II lowpass filter prototype (normalized cutoff = 1 rad/s).
enum constant speaker_arrangement::Cine30 L, R, C (cinema 3.0).
enum constant speaker_arrangement::Cine31 L, R, C, Lfe (cinema 3.1).
enum constant speaker_arrangement::Cine40 L, R, C, Cs (cinema 4.0).
enum constant speaker_arrangement::Cine41 L, R, C, Cs, Lfe (cinema 4.1).
enum constant speaker_arrangement::Cine60 L, R, C, Ls, Rs, Cs (cinema 6.0).
enum constant speaker_arrangement::Cine61 L, R, C, Lfe, Ls, Rs, Cs (cinema 6.1).
enum constant speaker_arrangement::Cine70 L, R, C, Ls, Rs, Lc, Rc (cinema 7.0).
enum constant speaker_arrangement::Cine71 L, R, C, Lfe, Ls, Rs, Lc, Rc (cinema 7.1).
enum constant speaker_arrangement::Cine80 L, R, C, Ls, Rs, Lc, Rc, Cs (cinema 8.0).
enum constant speaker_arrangement::Cine81 L, R, C, Lfe, Ls, Rs, Lc, Rc, Cs (cinema 8.1).
variable expression_goertzel<T>::coeff Precomputed resonator coefficient
variable expression_parallel_goertzel<T, width>::coeff Precomputed coefficients
enum constant window_type::cosine
enum constant window_type::cosine_np
function ebu_r128<T>::count() Return the number of channels.
enum constant speaker_type::Cs Alias for S (center surround).
variable delay_state<T, samples, Tag>::cursor
function cweighting(const T1 &) C-weighting filter response for a scalar frequency.
function cweighting(E1 &&) C-weighting filter response as an expression.
variable cwindow_type Compile-time window type value
typedef cwindow_type_t Compile-time window type tag

D¶

variable delay_state<T, samples, Tag>::data
variable delay_state<T, 1, 1>::data
function dB_to_amp(const T1 &) Convert a level in decibels to an amplitude (10^(dB/20)).
function dB_to_amp(E1 &&) Convert a decibel level expression to amplitudes (10^(dB/20)).
function dB_to_power(const T1 &) Convert a power level in decibels to a power value (10^(dB/10)).
function dB_to_power(E1 &&) Convert a power level expression in decibels to power values (10^(dB/10)).
function dcremove(E1 &&, double)
function dcremove(E1 &&, double, double) Applies a DC removal filter to the given input expression.
variable samplerate_converter<T>::decimation_factor Decimation factor.
variable samplerate_converter<T>::delay Delay line buffer.
class delay_state<T, 1, 1>
class delay_state<T, samples, Tag>
constructor delay_state<T, samples, Tag>::delay_state<T, samples, Tag>()
function delay(delay_state<T, samples, STag> &, E1 &&) Returns template expression that applies delay to the input (uses ring buffer in state)
function delay(E1 &&) Returns template expression that applies delay to the input (uses ring buffer internally)
function delay(E1 &&, std::reference_wrapper<delay_state<T, samples, STag>>) Returns template expression that applies delay to the input (uses ring buffer in state)
variable short_fir_state<tapcount, T, U>::delayline Delay line holding the last
variable fir_state<T, U>::delayline Ring-buffer delay line of length
variable moving_sum_state<U, Tag>::delayline Ring buffer holding the window contents.
variable moving_sum_state<U, tag_dynamic_vector>::delayline Ring buffer holding the window contents.
variable fir_state<T, U>::delayline_cursor Current write cursor into
variable samplerate_converter<T>::depth Processing depth.
variable expression_window<T>::dims
variable expression_delay<delay, E, stateless, STag>::dims
variable expression_delay<1, E, stateless, STag>::dims
variable expression_goertzel<T>::dims
variable expression_parallel_goertzel<T, width>::dims
function downsample2(E1 &&, csize_t<offset>) Downsamples a signal by a factor of 2 by selecting every other sample.
function downsample4(E1 &&, csize_t<offset>) Downsamples a signal by a factor of 4 by selecting every fourth sample.
enum constant sample_rate_conversion_quality::draft Draft quality (lowest, fastest).

E¶

class ebu_channel<T> Single-channel loudness measurement front-end.
constructor ebu_channel<T>::ebu_channel<T>(int, speaker_type, int, T) Construct a channel front-end.
class ebu_r128<T> EBU R128 loudness meter.
constructor ebu_r128<T>::ebu_r128<T>(int, std::span<const speaker_type>, int) Construct the meter.
function elliptic(int, double, double) Analog elliptic (Cauer) lowpass filter prototype (normalized cutoff = 1 rad/s).
function end_pass(const expression_iir<1, T, E1, Stateless> &, shape<1>, shape<1>) Internal ADL-provided implementation for
function end_pass(const expression_iir<filters, T, E1, Stateless> &, shape<1>, shape<1>) Internal ADL-provided implementation for
function energy_to_loudness(T) Convert mean-square energy to loudness in LUFS.
class expression_bartlett_hann<T> Bartlett-Hann window expression
class expression_bartlett<T> Bartlett window expression (triangular reaching zero at the edges)
typedef expression_biquads Alias for expression_iir (sample-by-sample biquad cascade expression).
typedef expression_biquads_l Alias for expression_iir_l (look-ahead biquad cascade expression).
class expression_blackman_harris<T> Blackman-Harris window expression (4-term minimum sidelobe window)
class expression_blackman<T> Blackman window expression (parameterized by alpha)
constructor expression_blackman<T>::expression_blackman<T>(size_t, T, window_symmetry)
class expression_bohman<T> Bohman window expression (product of cosine and linear taper)
class expression_cosine_np<T> Cosine window expression (numpy-compatible)
class expression_cosine<T> Cosine window expression (sin(pi*x))
class expression_delay<1, E, stateless, STag>
constructor expression_delay<1, E, stateless, STag>::expression_delay<1, E, stateless, STag>(E &&, state_holder<delay_state<T, 1, STag>, stateless>)
class expression_delay<delay, E, stateless, STag>
constructor expression_delay<delay, E, stateless, STag>::expression_delay<delay, E, stateless, STag>(E &&, state_holder<delay_state<T, delay, STag>, stateless>)
class expression_fir<T, U, E1, stateless> Template expression applying a generic FIR filter of arbitrary length.
constructor expression_fir<T, U, E1, stateless>::expression_fir<T, U, E1, stateless>(E1 &&, state_holder<fir_state<T, U>, stateless>)
class expression_flattop<T> Flat-top window expression (5-term window for accurate amplitude estimation)
class expression_gaussian<T> Gaussian window expression
constructor expression_gaussian<T>::expression_gaussian<T>(size_t, T, window_symmetry) alpha = std / 2N
class expression_goertzel<T> Single-bin Goertzel algorithm expression.
destructor expression_goertzel<T>::~expression_goertzel<T>() Destructor: rotates the final filter state into the complex DFT bin value and stores it in result .
constructor expression_goertzel<T>::expression_goertzel<T>(complex<T> &, T) Construct a Goertzel resonator for frequency omega .
class expression_hamming<T> Hamming window expression
constructor expression_hamming<T>::expression_hamming<T>(size_t, T, window_symmetry)
class expression_hann<T> Hann window expression (0.5*(1-cos(2*pi*x)))
class expression_iir_l<filters, T, E1, Stateless> Template expression applying a cascade of biquad sections (look-ahead variant, no latency compensation).
constructor expression_iir_l<filters, T, E1, Stateless>::expression_iir_l<filters, T, E1, Stateless>(E1 &&, state_holder<iir_state<T, filters>, Stateless>) Construct from an input expression and a state holder.
class expression_iir<filters, T, E1, Stateless> Template expression applying a cascade of biquad sections (look-ahead variant, with latency compensation).
constructor expression_iir<filters, T, E1, Stateless>::expression_iir<filters, T, E1, Stateless>(E1 &&, state_holder<iir_state<T, filters>, Stateless>) Construct from an input expression and a state holder.
class expression_kaiser<T> Kaiser window expression (shaped by the zeroth-order modified Bessel function)
constructor expression_kaiser<T>::expression_kaiser<T>(size_t, T, window_symmetry)
class expression_lanczos<T> Lanczos window expression (sinc based)
class expression_moving_sum<U, E1, STag, stateless> Template expression performing a moving sum (rectangular window) over the input.
constructor expression_moving_sum<U, E1, STag, stateless>::expression_moving_sum<U, E1, STag, stateless>(E1 &&, state_holder<moving_sum_state<U, STag>, stateless>)
class expression_parallel_goertzel<T, width> Parallel (multi-bin) Goertzel algorithm expression.
destructor expression_parallel_goertzel<T, width>::~expression_parallel_goertzel<T, width>() Destructor: rotates the final filter states into the width complex DFT bin values and stores them in result .
constructor expression_parallel_goertzel<T, width>::expression_parallel_goertzel<T, width>(complex<T> *, vec<T, width>) Construct width parallel Goertzel resonators.
class expression_planck_taper<T> Planck-taper window expression (smooth flat-top taper controlled by epsilon)
constructor expression_planck_taper<T>::expression_planck_taper<T>(size_t, T, window_symmetry)
class expression_rectangular<T> Rectangular window expression (all ones within the window)
constructor expression_rectangular<T>::expression_rectangular<T>(size_t, T, window_symmetry)
class expression_short_fir<tapcount, T, U, E1, stateless> Template expression applying a short FIR filter (2..33 taps).
constructor expression_short_fir<tapcount, T, U, E1, stateless>::expression_short_fir<tapcount, T, U, E1, stateless>(E1 &&, state_holder<short_fir_state<tapcount, T, U>, stateless>)
class expression_triangular<T> Triangular window expression
class expression_tukey<T> Tukey window expression (tapered cosine, numpy-compatible)
constructor expression_tukey<T>::expression_tukey<T>(size_t, T, window_symmetry)
class expression_window_with_metrics<T, metrics> Base class for windows parameterized by a linspace and a scalar argument
constructor expression_window_with_metrics<T, metrics>::expression_window_with_metrics<T, metrics>(size_t, T, window_symmetry)
class expression_window<T> Base class for all window expressions
constructor expression_window<T>::expression_window<T>(size_t)

F¶

variable samplerate_converter<T>::filter Filter coefficients.
typedef filter_fir Alias for
function samplerate_converter<T>::filter_order(sample_rate_conversion_quality) Computes the filter order for a given quality level.
function filtfilt(univector<T, Tag> &, const iir_params<T, Itag> &) Applies forward and backward filtering to the input array using the given IIR filter parameters.
function fir_bandpass(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_bandpass(univector<T, Tag> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the band-pass FIR filter using the windowed-sinc method.
function fir_bandstop(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_bandstop(univector<T, Tag> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the band-stop (notch) FIR filter using the windowed-sinc method.
class fir_filter<T, U> Runtime FIR filter implementing the filter<U> interface.
constructor fir_filter<T, U>::fir_filter<T, U>(fir_state<T, U>) Construct from a fir_state .
function fir_highpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_highpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the high-pass FIR filter using the windowed-sinc method.
function fir_lowpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_lowpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the low-pass FIR filter using the windowed-sinc method.
deduction guide fir_params Deduction guide for fir_params from an arbitrary container.
class fir_params<T> Parameters of a generic FIR filter: the tap vector.
constructor fir_params<T>::fir_params<T>(const fir_params<T> &)
constructor fir_params<T>::fir_params<T>(const T *, size_t) Construct from a raw pointer and size (taps are reversed internally).
function fir_params<T>::fir_params<T>(Cont &&) Construct from any container satisfying has_data_size .
constructor fir_params<T>::fir_params<T>(fir_params<T> &&)
constructor fir_params<T>::fir_params<T>(univector<T> &&) Construct by moving a tap vector (taps are reversed internally).
deduction guide fir_state Deduction guide for fir_state from an arbitrary container.
class fir_state<T, U> State of a generic FIR filter: parameters plus a ring-buffer delay line.
constructor fir_state<T, U>::fir_state<T, U>(const fir_state<T, U> &)
function fir_state<T, U>::fir_state<T, U>(Cont &&) Construct from a tap container (taps are reversed by fir_params ).
constructor fir_state<T, U>::fir_state<T, U>(fir_params<T>) Construct from fir_params (taps are taken as-is, already reversed).
constructor fir_state<T, U>::fir_state<T, U>(fir_state<T, U> &&)
typedef fir_taps Alias for a fixed-size vector of FIR filter coefficients.
function fir(E1 &&, fir_params<T>) Returns template expression that applies FIR filter to the input.
function fir(E1 &&, std::reference_wrapper<fir_state<T, U>>) Returns template expression that applies FIR filter to the input.
function fir(E1 &&, Taps &&) Returns template expression that applies FIR filter to the input.
function fir(fir_state<T, U> &, E1 &&) Returns template expression that applies FIR filter to the input.
enum constant window_type::flattop
function fracdelay(E1 &&, T) Returns template expression that applies a fractional delay to the input
typedef samplerate_converter<T>::ftype

G¶

enum constant window_type::gaussian
function integrated_vec<T>::get() Return the integrated loudness in LUFS, recomputing if needed.
function samplerate_converter<T>::get_delay() Gets the integer delay introduced by the resampler.
function expression_bartlett_hann<T>::get_elements(const expression_bartlett_hann<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_bartlett<T>::get_elements(const expression_bartlett<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_blackman_harris<T>::get_elements(const expression_blackman_harris<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_blackman<T>::get_elements(const expression_blackman<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_bohman<T>::get_elements(const expression_bohman<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_cosine_np<T>::get_elements(const expression_cosine_np<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_cosine<T>::get_elements(const expression_cosine<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_delay<1, E, stateless, STag>::get_elements(const expression_delay<1, E, stateless, STag> &, shape<1>, axis_params<0, N>)
function expression_delay<delay, E, stateless, STag>::get_elements(const expression_delay<delay, E, stateless, STag> &, shape<1>, axis_params<0, 1>)
function expression_delay<delay, E, stateless, STag>::get_elements(const expression_delay<delay, E, stateless, STag> &, shape<1>, axis_params<0, N>)
function expression_fir<T, U, E1, stateless>::get_elements(const expression_fir<T, U, E1, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_fir expressions.
function expression_flattop<T>::get_elements(const expression_flattop<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_gaussian<T>::get_elements(const expression_gaussian<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_hamming<T>::get_elements(const expression_hamming<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_hann<T>::get_elements(const expression_hann<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_iir<1, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_iir_l<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_iir<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_kaiser<T>::get_elements(const expression_kaiser<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_lanczos<T>::get_elements(const expression_lanczos<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_moving_sum<U, E1, STag, stateless>::get_elements(const expression_moving_sum<U, E1, STag, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_moving_sum expressions.
function expression_planck_taper<T>::get_elements(const expression_planck_taper<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_rectangular<T>::get_elements(const expression_rectangular<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_short_fir<tapcount, T, U, E1, stateless>::get_elements(const expression_short_fir<tapcount, T, U, E1, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_short_fir expressions.
function expression_triangular<T>::get_elements(const expression_triangular<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_tukey<T>::get_elements(const expression_tukey<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function samplerate_converter<T>::get_fractional_delay() Gets the fractional delay introduced by the resampler.
function expression_window<T>::get_shape()
function expression_delay<delay, E, stateless, STag>::get_shape()
function expression_delay<1, E, stateless, STag>::get_shape()
function expression_goertzel<T>::get_shape()
function expression_parallel_goertzel<T, width>::get_shape()
function expression_delay<1, E, stateless, STag>::get_shape(const expression_delay<1, E, stateless, STag> &)
function expression_delay<delay, E, stateless, STag>::get_shape(const expression_delay<delay, E, stateless, STag> &)
function expression_goertzel<T>::get_shape(const expression_goertzel<T> &)
function expression_parallel_goertzel<T, width>::get_shape(const expression_parallel_goertzel<T, width> &)
function expression_window<T>::get_shape(const expression_window<T> &)
function ebu_channel<T>::get_speaker() Return the speaker role assigned to this channel.
function ebu_r128<T>::get_values(T &, T &, T &, T &, T &) Read all measured loudness values.
function lra_vec<T>::get(T &, T &) Return the LRA percentile loudness bounds.
function goertzel(complex<T> &, std::type_identity_t<T>) Create a single-bin Goertzel expression.
function goertzel(complex<T> (&)[width], const T (&)[width]) Create width parallel Goertzel expressions.

H¶

enum constant window_type::hamming
enum constant window_type::hann
variable moving_sum_state<U, Tag>::head_cursor Write cursor (newest sample).
variable moving_sum_state<U, tag_dynamic_vector>::head_cursor Write cursor (newest sample).
function hertz_to_note(const T1 &) Convert a frequency in Hertz to a MIDI note number.
function hertz_to_note(E1 &&) Convert a frequency expression in Hertz to MIDI note numbers.
enum constant sample_rate_conversion_quality::high High quality.
enum constant biquad_type::highpass Passes frequencies above the cutoff.
enum constant biquad_type::highshelf High-shelf equalizer filter.

I¶

function iir_bandpass(const zpk &, double, double, double) Designs a digital bandpass IIR filter and returns ZPK coefficients.
function iir_bandstop(const zpk &, double, double, double) Designs a digital bandstop (notch) IIR filter and returns ZPK coefficients.
class iir_filter<T> Runtime IIR filter object usable as a streaming filter.
constructor iir_filter<T>::iir_filter<T>(const iir_params<T> &) Construct the filter from biquad parameters.
function iir_highpass(const zpk &, double, double) Designs a digital highpass IIR filter and returns ZPK coefficients.
function iir_lowpass(const zpk &, double, double) Designs a digital lowpass IIR filter and returns ZPK coefficients.
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
class iir_params<T, filters> Fixed-size container of biquad coefficients stored as SoA vectors.
constructor iir_params<T, filters>::iir_params<T, filters>() Default constructor: pass-through (b0=1, rest 0).
constructor iir_params<T, filters>::iir_params<T, filters>(const biquad_section<T> &) Construct from a single biquad_section.
constructor iir_params<T, filters>::iir_params<T, filters>(const biquad_section<T> *, size_t) Build from an array of biquad_section.
function iir_params<T, filters>::iir_params<T, filters>(Container &&) Construct from any container with data()/size().
class iir_params<T, tag_dynamic_vector> Dynamic-size specialization of iir_params.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>()
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const biquad_section<T> &) Construct from a single biquad_section.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const biquad_section<T> *, size_t) Build from a C array of
function iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const iir_params<T, filters> &) Convert a fixed-size iir_params to the dynamic-size form.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const iir_params<T, tag_dynamic_vector> &)
function iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(Container &&) Construct from any container with data()/size().
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(iir_params<T, tag_dynamic_vector> &&)
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(size_t) Allocate storage for
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(std::vector<biquad_section<T>> &&) Move-construct from a vector of sections.
deduction guide iir_state
deduction guide iir_state
class iir_state<T, filters> Combined IIR filter parameters and runtime state.
function iir_state<T, filters>::iir_state<T, filters>(Args &&...) Forwarding constructor for the embedded iir_params.
function iir(E1 &&, const iir_params<T, tag_dynamic_vector> &) Returns a template expression that applies a runtime-sized biquad cascade to the input.
function iir(E1 &&, const zpk &) Applies an IIR filter (in ZPK form) to an input signal expression.
function iir(E1 &&, iir_params<T, filters>) Returns a template expression that applies a biquad filter cascade to the input.
function iir(E1 &&, std::reference_wrapper<iir_state<T, filters>>) Returns a template expression that applies a biquad cascade using externally-owned state.
variable samplerate_converter<T>::input_position Current input position.
function samplerate_converter<T>::input_position_to_intermediate(itype) Converts an input position to an intermediate (interpolated) position.
function samplerate_converter<T>::input_position_to_output(itype) Converts an input position to the corresponding output position.
function samplerate_converter<T>::input_size_for_output(itype) Calculates the input size required to produce a given output size (pull method).
class integrated_vec<T> Buffer of momentary mean-square energies used to compute the integrated (program) loudness per EBU R128 §3560.
constructor integrated_vec<T>::integrated_vec<T>()
variable samplerate_converter<T>::interpolation_factor Interpolation factor.
function isawtooth(const T1 &) Inverse (rising) sawtooth wave of a phase in radians.
function isawtooth(E1 &&) Expression overload of isawtooth ; applies element-wise to an expression.
function isawtoothnorm(const T1 &) Inverse (rising) sawtooth wave of a phase ramp in [0, 1) cycles.
function isawtoothnorm(E1 &&) Expression overload of isawtoothnorm ; applies element-wise to an expression.
typedef samplerate_converter<T>::itype

J¶

function jaehne_arg(size_t)
function jaehne(std::type_identity_t<T>, size_t) Returns expression template that generates a jaehne vector Generates the sine with linearly increasing frequency from 0hz to nyquist frequency.

K¶

variable zpk::k System gain
enum constant window_type::kaiser
variable samplerate_converter<T>::kaiser_beta Kaiser window beta parameter.
macro KFR_WINDOW_BY_TYPE

L¶

enum constant speaker_type::L Alias for Left.
enum constant window_type::lanczos
enum constant speaker_type::Lc Left center (front, between L and C).
enum constant speaker_type::Left Front left.
enum constant speaker_type::LeftSurround Alias for Ls.
enum constant speaker_type::Lfe Low-frequency effects (subwoofer).
enum constant speaker_type::Lfe2 Second low-frequency effects channel.
function library_version_dsp() Returns the full version string of the KFR DSP module.
variable expression_window_with_metrics<T, metrics>::linspace
function loudness_to_energy(T) Inverse of energy_to_loudness : convert LUFS back to linear energy.
enum constant sample_rate_conversion_quality::low Low quality.
enum constant biquad_type::lowpass Passes frequencies below the cutoff.
enum constant biquad_type::lowshelf Low-shelf equalizer filter.
class lra_vec<T> Sorted buffer of short-term mean-square energies used to compute the Loudness Range (LRA) per EBU R128 / ITU-R BS.1770.
constructor lra_vec<T>::lra_vec<T>()
enum constant speaker_type::Ls Left surround.

M¶

enum constant speaker_type::M Alias for Mono.
variable expression_window<T>::m_size
function make_kfilter(int) Build the EBU R128 K-weighting pre-filter as an IIR expression handle.
variable stereo_matrix::matrix 2x2 mixing matrix (rows are output coefficients).
function matrix_halfsum_halfdiff() Returns a 2x2 matrix that computes half-sum/half-difference of stereo channels.
function matrix_sum_diff() Returns a 2x2 matrix that computes sum/difference of stereo channels.
variable maximum_biquad_count Maximum number of cascaded biquad sections (maximum_iir_order / 2).
variable maximum_iir_order Maximum supported IIR filter order.
enum constant window_metrics::metrics_0_1
enum constant window_metrics::metrics_m1_1
enum constant window_metrics::metrics_m1_1_trunc
enum constant window_metrics::metrics_m1_1_trunc2
enum constant window_metrics::metrics_mpi_pi
function mixdown_stereo(Left &&, Right &&, const f64x2x2 &) Returns a template expression that produces a length-2 vector mixing the left and right channels according to matrix .
function mixdown(E &&...) Returns a template expression that yields the sample-wise sum of all the inputs.
enum constant speaker_type::Mono Mono (front center, single channel).
enum constant speaker_arrangement::Mono Single mono channel (M).
class moving_sum_state<U, Tag> State for a moving-sum (rectangular window) filter with a compile-time-sized delay line.
constructor moving_sum_state<U, Tag>::moving_sum_state<U, Tag>()
class moving_sum_state<U, tag_dynamic_vector> Specialization of moving_sum_state for a runtime-sized window.
constructor moving_sum_state<U, tag_dynamic_vector>::moving_sum_state<U, tag_dynamic_vector>(size_t) Construct a moving-sum state with the given window length.
function moving_sum(E1 &&) Returns template expression that performs moving sum on the input.
function moving_sum(E1 &&, size_t) Returns template expression that performs moving sum on the input.
function moving_sum(E1 &&, std::reference_wrapper<moving_sum_state<U, Tag>>) Returns template expression that performs moving sum on the input.
function moving_sum(moving_sum_state<U, STag> &, E1 &&) Returns template expression that performs moving sum on the input.
enum constant speaker_arrangement::Music30 L, R, S (music 3.0).
enum constant speaker_arrangement::Music31 L, R, S, Lfe (music 3.1).
enum constant speaker_arrangement::Music40 L, R, Ls, Rs (music 4.0).
enum constant speaker_arrangement::Music41 L, R, Ls, Rs, Lfe (music 4.1).
enum constant speaker_arrangement::Music60 L, R, Ls, Rs, Sl, Sr (music 6.0).
enum constant speaker_arrangement::Music61 L, R, Lfe, Ls, Rs, Sl, Sr (music 6.1).
enum constant speaker_arrangement::Music70 L, R, C, Ls, Rs, Sl, Sr (music 7.0).
enum constant speaker_arrangement::Music71 L, R, C, Lfe, Ls, Rs, Sl, Sr (music 7.1).
enum constant speaker_arrangement::Music80 L, R, C, Ls, Rs, Sl, Sr, Cs (music 8.0).
enum constant speaker_arrangement::Music81 L, R, C, Lfe, Ls, Rs, Sl, Sr, Cs (music 8.1).

N¶

enum constant speaker_type::None No speaker / unspecified.
enum constant speaker_arrangement::None No arrangement / unspecified.
enum constant sample_rate_conversion_quality::normal Normal quality (balanced).
function biquad_section<T>::normalized_a0() Returns a section scaled so that a0 == 1.
function biquad_section<T>::normalized_all() Returns a section scaled so that both a0 == 1 and b0 == 1.
function biquad_section<T>::normalized_b0() Returns a section scaled so that b0 == 1.
enum constant biquad_type::notch Notch (band-reject) filter.
function note_to_hertz(const T1 &) Convert a MIDI note number to frequency in Hertz.
function note_to_hertz(E1 &&) Convert a MIDI note number expression to frequency in Hertz.

O¶

variable expression_goertzel<T>::omega Target angular frequency [rad/sample].
variable expression_parallel_goertzel<T, width>::omega SIMD vector of target angular frequencies.
function fir_params<T>::operator=(const fir_params<T> &)
function fir_state<T, U>::operator=(const fir_state<T, U> &)
function stereo_matrix::operator()(const vec<vec<T, 2>, N> &) Apply the matrix to a vector of stereo samples.
function fir_params<T>::operator=(fir_params<T> &&)
function fir_state<T, U>::operator=(fir_state<T, U> &&)
function samplerate_converter<T>::operator=(samplerate_converter<T> &&) Move assignment operator.
function ebu_r128<T>::operator[](size_t) Access channel index (read-only).
variable samplerate_converter<T>::order Filter order.
variable biquad_state<T, filters>::out Last output vector, used as inter-section delay line.
variable samplerate_converter<T>::output_position Current output position.
function samplerate_converter<T>::output_position_to_input(itype) Converts an output position to the corresponding input position.
function samplerate_converter<T>::output_position_to_intermediate(itype) Converts an output position to an intermediate (pre-decimation) position.
function samplerate_converter<T>::output_size_for_input(itype) Calculates the output size produced for a given input size (push method).

P¶

variable zpk::p Poles of the transfer function
function ebu_channel<T>::packet_size() Return the number of samples per packet.
function ebu_r128<T>::packet_size() Return the number of samples per packet (= sample_rate / refresh_rate).
variable iir_state<T, filters>::params
variable fir_state<T, U>::params Filter parameters (reversed taps).
enum constant biquad_type::peak Peaking equalizer filter.
enum constant sample_rate_conversion_quality::perfect Perfect quality (highest, slowest).
enum constant window_symmetry::periodic
function phasor(std::type_identity_t<T>) Phasor with sample_rate = 1 and phase = 0 .
function phasor(std::type_identity_t<T>, std::type_identity_t<T>, std::type_identity_t<T>) Phasor (normalized phase ramp in [0, 1)) advancing at the given frequency.
enum constant window_type::planck_taper
function power_to_dB(const T1 &) Convert a power value to decibels (10*log10).
function power_to_dB(E1 &&) Convert a power expression to decibels (10*log10).
function fir_filter<T, U>::process_buffer(U *, const U *, size_t)
function fir_filter<T, U>::process_expression(U *, const expression_handle<U, 1> &, size_t)
function samplerate_converter<T>::process_impl(univector_ref<T>, univector_ref<const T>) Internal implementation of the process function.
function ebu_r128<T>::process_packet(const std::initializer_list<univector_dyn<T>> &) Process one packet for every channel.
function ebu_r128<T>::process_packet(const std::initializer_list<univector_ref<T>> &)
function ebu_channel<T>::process_packet(const T *) Process one packet of packet_size() samples.
function ebu_r128<T>::process_packet(std::span<const univector_dyn<T>>)
function ebu_r128<T>::process_packet(std::span<const univector_ref<T>>)
function stereo_matrix::process(const vec<vec<T, 2>, N> &, csizes_t<indices...>) Internal ADL-provided implementation for stereo_matrix expressions.
function samplerate_converter<T>::process(univector<T, Tag> &, univector_ref<const T>) Processes input data to produce resampled output (pull or push method).
function fir_state<T, U>::push_delayline(Cont &&) Append samples to the delay line ring buffer.
function integrated_vec<T>::push(T) Append a momentary mean-square energy sample.
function lra_vec<T>::push(T) Insert a short-term mean-square energy sample, keeping the buffer sorted.

Q¶

variable expression_goertzel<T>::q0 Current filter output (working state).
variable expression_parallel_goertzel<T, width>::q0 Current filter outputs (working state).
variable expression_goertzel<T>::q1 Previous output sample (working state).
variable expression_parallel_goertzel<T, width>::q1 Previous output samples (working state).
variable expression_goertzel<T>::q2 Output sample two steps back (working state).
variable expression_parallel_goertzel<T, width>::q2 Output samples two steps back (working state).

R¶

enum constant speaker_type::R Alias for Right.
variable expression_short_fir<tapcount, T, U, E1, stateless>::random_access
variable expression_fir<T, U, E1, stateless>::random_access
variable expression_moving_sum<U, E1, STag, stateless>::random_access
variable expression_delay<delay, E, stateless, STag>::random_access
variable expression_delay<1, E, stateless, STag>::random_access
function rawsawtooth(const T1 &) Sawtooth wave of a phase ramp in [0, 1) cycles.
function rawsawtooth(E1 &&) Expression overload of rawsawtooth ; applies element-wise to an expression.
function rawsine(const T1 &) Sine of a phase ramp in [0, 1) cycles.
function rawsine(E1 &&) Expression overload of rawsine ; applies element-wise to an expression.
function rawsquare(const T1 &) Square wave of a phase ramp in [0, 1) cycles.
function rawsquare(E1 &&) Expression overload of rawsquare ; applies element-wise to an expression.
function rawtriangle(const T1 &) Triangle wave of a phase ramp in [0, 1) cycles.
function rawtriangle(E1 &&) Expression overload of rawtriangle ; applies element-wise to an expression.
enum constant speaker_type::Rc Right center (front, between R and C).
enum constant window_type::rectangular
typedef resample_quality Alias for sample_rate_conversion_quality.
function resampler(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>) Helper function to create a sample rate converter instance.
function fir_filter<T, U>::reset() Reset internal filter state
function integrated_vec<T>::reset() Clear the buffer and invalidate the cached result.
function lra_vec<T>::reset() Clear the buffer and invalidate the cached result.
function ebu_channel<T>::reset() Zero the momentary and short-term sum-of-squares ring buffers.
function ebu_r128<T>::reset() Request a deferred reset of all channels and accumulators.
function samplerate_converter<T>::reset() Resets the converter to its initial state.
function reset(const expression_delay<1, E, stateless, STag> &) Clears a one-sample delay expression's stored sample.
function reset(const expression_delay<delay, E, stateless, STag> &) Clears a multi-sample delay expression's ring buffer and cursor.
function reset(const expression_fir<T, U, E1, stateless> &) Clears a generic FIR expression's delay line while preserving its taps.
function reset(const expression_goertzel<T> &) Clears a Goertzel resonator's recursive state.
function reset(const expression_iir_l<filters, T, E1, Stateless> &) Clears an IIR cascade's delay-line state while preserving its coefficients.
function reset(const expression_iir<filters, T, E1, Stateless> &)
function reset(const expression_moving_sum<U, E1, STag, stateless> &) Clears a moving-sum expression's delay line and restores its cursors.
function reset(const expression_parallel_goertzel<T, width> &) Clears all recursive states in a parallel Goertzel expression.
function reset(const expression_short_fir<tapcount, T, U, E1, stateless> &) Clears a short FIR expression's delay line while preserving its taps.
variable expression_goertzel<T>::result Output complex bin value (written on destruction).
variable expression_parallel_goertzel<T, width>::result Output array of
enum constant speaker_type::Right Front right.
enum constant speaker_type::RightSurround Alias for Rs.
enum constant speaker_type::Rs Right surround.
function ebu_r128<T>::running() Return whether the meter is currently running (see start() , stop() ).

S¶

enum constant speaker_type::S Rear surround (single).
variable biquad_state<T, filters>::s1 First delay register per section.
variable biquad_state<T, filters>::s2 Second delay register per section.
function ebu_r128<T>::sample_rate() Return the configured sample rate in Hz.
enum sample_rate_conversion_quality Defines the quality levels for sample rate conversion.
function sample_rate_converter(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>) Helper function to create a sample rate converter instance.
typedef sample_rate_t Sample rate expressed in Hertz.
class samplerate_converter<T> A template class for performing sample rate conversion on audio signals.
constructor samplerate_converter<T>::samplerate_converter<T>() Default constructor.
constructor samplerate_converter<T>::samplerate_converter<T>(int, itype, itype, fbase, fbase, fbase, fbase) Constructs a sample rate converter from explicit filter parameters.
constructor samplerate_converter<T>::samplerate_converter<T>(sample_rate_conversion_quality, itype, itype, fbase, fbase) Constructs a sample rate converter.
constructor samplerate_converter<T>::samplerate_converter<T>(samplerate_converter<T> &&) Move constructor.
function saturate_I(const T1 &) Type-I saturation curve (odd-symmetric, bounded to (-1, 1)).
function saturate_I(E1 &&) Expression form of saturate_I.
function saturate_II(const T1 &) Type-II saturation curve (odd-symmetric, bounded to (-1, 1)).
function saturate_II(E1 &&) Expression form of saturate_II.
variable iir_state<T, filters>::saved_state Snapshot used for block-based processing.
function sawtooth(const T1 &) Sawtooth wave of a phase in radians.
function sawtooth(E1 &&) Expression overload of sawtooth ; applies element-wise to an expression.
function sawtoothnorm(const T1 &) Sawtooth wave of a phase ramp in [0, 1) cycles (alias of rawsawtooth ).
function sawtoothnorm(E1 &&) Expression overload of sawtoothnorm ; applies element-wise to an expression.
function expression_goertzel<T>::set_elements(expression_goertzel<T> &, shape<1>, axis_params<VecAxis, N>, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for expression_goertzel expressions.
function expression_parallel_goertzel<T, width>::set_elements(expression_parallel_goertzel<T, width> &, shape<1>, axis_params<VecAxis, N>, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for expression_parallel_goertzel expressions.
function fir_filter<T, U>::set_params(fir_params<T>) Replace the filter parameters (alias of
function fir_filter<T, U>::set_taps(fir_params<T>) Replace the filter taps (resets parameters; delay line is unchanged until next process).
class short_fir_state<tapcount, T, U> State for a short FIR filter (tap count in range 2..33).
function short_fir_state<tapcount, T, U>::short_fir_state<tapcount, T, U>(const univector<const T, N> &) Construct from a runtime-sized tap vector (const data variant).
function short_fir_state<tapcount, T, U>::short_fir_state<tapcount, T, U>(const univector<T, N> &) Construct from a runtime-sized tap vector.
function short_fir(E1 &&, const univector<T, TapCount> &) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function short_fir(E1 &&, std::reference_wrapper<short_fir_state<TapCount, T, U>>) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function short_fir(short_fir_state<InternalTapCount, T, U> &, E1 &&) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function samplerate_converter<T>::sidelobe_att() Calculates the sidelobe attenuation based on the Kaiser beta parameter.
function samplerate_converter<T>::sidelobe_attenuation(sample_rate_conversion_quality) Returns the sidelobe attenuation for a given quality level.
function sine(const T1 &) Sine of a phase in radians.
function sine(E1 &&) Expression overload of sine ; applies element-wise to an expression.
function sinenorm(const T1 &) Sine of a phase ramp in [0, 1) cycles (alias of rawsine ).
function sinenorm(E1 &&) Expression overload of sinenorm ; applies element-wise to an expression.
function expression_window<T>::size()
function samplerate_converter<T>::skip(size_t, univector_ref<const T>) Skips a specified number of output samples, updating internal state.
enum constant speaker_type::Sl Side left.
typedef Speaker
enum speaker_arrangement Predefined speaker arrangements.
enum speaker_type Speaker types (channel positions).
typedef SpeakerArrangement
function square(const T1 &) Square wave of a phase in radians.
function square(E1 &&) Expression overload of square ; applies element-wise to an expression.
function squarenorm(const T1 &) Square wave of a phase ramp in [0, 1) cycles (alias of rawsquare ).
function squarenorm(E1 &&) Expression overload of squarenorm ; applies element-wise to an expression.
enum constant speaker_type::Sr Side right.
function ebu_r128<T>::start() (Re)start measurement: subsequent packets update the buffers.
variable iir_state<T, filters>::state Active delay-line state.
variable expression_iir_l<filters, T, E1, Stateless>::state
variable expression_iir<filters, T, E1, Stateless>::state
variable expression_short_fir<tapcount, T, U, E1, stateless>::state
variable expression_fir<T, U, E1, stateless>::state
variable expression_moving_sum<U, E1, STag, stateless>::state
variable fir_filter<T, U>::state
variable expression_delay<delay, E, stateless, STag>::state
variable expression_delay<1, E, stateless, STag>::state
enum constant speaker_arrangement::Stereo L, R.
struct stereo_matrix 2x2 mixing matrix functor for stereo channel transformations.
enum constant speaker_arrangement::StereoCenter Lc, Rc.
enum constant speaker_arrangement::StereoCLfe C, Lfe.
enum constant speaker_arrangement::StereoSide Sl, Sr.
enum constant speaker_arrangement::StereoSurround Ls, Rs.
function ebu_r128<T>::stop() Pause measurement: packets are still filtered but buffers are frozen.
function swept_arg(size_t)
function swept(std::type_identity_t<T>, size_t) Returns expression template that generates a jaehne vector Generates the sine with logarithmically increasing frequency from 0hz to nyquist frequency.
enum constant window_symmetry::symmetric

T¶

typedef expression_delay<delay, E, stateless, STag>::T
typedef expression_delay<1, E, stateless, STag>::T
variable moving_sum_state<U, Tag>::tail_cursor Read cursor (oldest sample).
variable moving_sum_state<U, tag_dynamic_vector>::tail_cursor Read cursor (oldest sample).
variable short_fir_state<tapcount, T, U>::taps Filter coefficients (zero-padded).
variable fir_params<T>::taps Filter coefficients (reversed order).
variable samplerate_converter<T>::taps Number of filter taps.
enum constant speaker_type::Tfc Top front center.
enum constant speaker_type::Tfl Top front left.
enum constant speaker_type::Tfr Top front right.
enum constant speaker_type::Tm Top middle.
function to_sos(const zpk &) Converts a zero-pole-gain filter to second-order sections (SOS) form.
function samplerate_converter<T>::transition_width() Calculates the transition width based on sidelobe attenuation and depth.
function samplerate_converter<T>::transition_width(sample_rate_conversion_quality) Returns the transition width for a given quality level.
enum constant speaker_type::Trc Top rear center.
function triangle(const T1 &) Triangle wave of a phase in radians.
function triangle(E1 &&) Expression overload of triangle ; applies element-wise to an expression.
function trianglenorm(const T1 &) Triangle wave of a phase ramp in [0, 1) cycles (alias of rawtriangle ).
function trianglenorm(E1 &&) Expression overload of trianglenorm ; applies element-wise to an expression.
enum constant window_type::triangular
enum constant speaker_type::Trl Top rear left.
enum constant speaker_type::Trr Top rear right.
enum constant window_type::tukey
typedef window_by_type<window_type::rectangular>::type
typedef window_by_type<window_type::triangular>::type
typedef window_by_type<window_type::bartlett>::type
typedef window_by_type<window_type::cosine>::type
typedef window_by_type<window_type::hann>::type
typedef window_by_type<window_type::bartlett_hann>::type
typedef window_by_type<window_type::hamming>::type
typedef window_by_type<window_type::bohman>::type
typedef window_by_type<window_type::blackman>::type
typedef window_by_type<window_type::blackman_harris>::type
typedef window_by_type<window_type::kaiser>::type
typedef window_by_type<window_type::flattop>::type
typedef window_by_type<window_type::gaussian>::type
typedef window_by_type<window_type::lanczos>::type
typedef window_by_type<window_type::cosine_np>::type
typedef window_by_type<window_type::planck_taper>::type
typedef window_by_type<window_type::tukey>::type

U¶

function unitimpulse() Returns expression template that generates a unit impulse
function upsample2(E1 &&) Upsamples a signal by a factor of 2 by inserting zero samples.
function upsample4(E1 &&) Upsamples a signal by a factor of 4 by inserting zero samples.

V¶

typedef expression_window<T>::value_type
typedef expression_iir_l<filters, T, E1, Stateless>::value_type
typedef expression_iir<filters, T, E1, Stateless>::value_type
typedef expression_short_fir<tapcount, T, U, E1, stateless>::value_type
typedef expression_fir<T, U, E1, stateless>::value_type
typedef expression_moving_sum<U, E1, STag, stateless>::value_type
typedef expression_delay<delay, E, stateless, STag>::value_type
typedef expression_delay<1, E, stateless, STag>::value_type
typedef expression_goertzel<T>::value_type
typedef expression_parallel_goertzel<T, width>::value_type

W¶

function waveshaper_hardclip(E1 &&, double) Hard-clipping waveshaper.
function waveshaper_poly(E1 &&, fbase, fbase, Cs...) Polynomial (odd-only) waveshaper using Horner evaluation.
function waveshaper_saturate_I(E1 &&, double) Waveshaper based on the type-I saturation curve.
function waveshaper_saturate_II(E1 &&, double) Waveshaper based on the type-II saturation curve.
function waveshaper_tanh(E1 &&, double) Hyperbolic-tangent waveshaper.
function window_bartlett_hann(size_t, ctype_t<T>) Returns template expression that generates a Bartlett-Hann window of length size
function window_bartlett(size_t, ctype_t<T>) Returns template expression that generates a Bartlett window of length size
function window_blackman_harris(size_t, window_symmetry, ctype_t<T>) Returns template expression that generates a Blackman-Harris window of length size
function window_blackman(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Blackman window of length size where α = alpha
function window_bohman(size_t, ctype_t<T>) Returns template expression that generates a Bohman window of length size
class window_by_type<window_type> Type trait mapping a window_type to its corresponding expression type
struct window_by_type<window_type::bartlett>
struct window_by_type<window_type::bartlett_hann>
struct window_by_type<window_type::blackman>
struct window_by_type<window_type::blackman_harris>
struct window_by_type<window_type::bohman>
struct window_by_type<window_type::cosine>
struct window_by_type<window_type::cosine_np>
struct window_by_type<window_type::flattop>
struct window_by_type<window_type::gaussian>
struct window_by_type<window_type::hamming>
struct window_by_type<window_type::hann>
struct window_by_type<window_type::kaiser>
struct window_by_type<window_type::lanczos>
struct window_by_type<window_type::planck_taper>
struct window_by_type<window_type::rectangular>
struct window_by_type<window_type::triangular>
struct window_by_type<window_type::tukey>
function window_cosine_np(size_t, ctype_t<T>) Returns template expression that generates a cosine window (numpy compatible) of length size
function window_cosine(size_t, ctype_t<T>) Returns template expression that generates a cosine window of length size
function window_flattop(size_t, ctype_t<T>) Returns template expression that generates a flat-top window of length size
function window_gaussian(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Gaussian window of length size where α = alpha
function window_hamming(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Hamming window of length size where α = alpha
function window_hann(size_t, ctype_t<T>) Returns template expression that generates a Hann window of length size
function window_kaiser(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Kaiser window of length size where β = beta
function window_lanczos(size_t, ctype_t<T>) Returns template expression that generates a Lanczos window of length size
class window_linspace<T> Linspace expression specialized for window abscissa generation
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_0_1>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1_trunc2>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1_trunc>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_mpi_pi>, size_t, window_symmetry)
enum window_metrics Selects the abscissa range and endpoint handling used by window expressions
function samplerate_converter<T>::window_param(fbase)
function samplerate_converter<T>::window_param(sample_rate_conversion_quality) Computes the Kaiser window parameter for a given quality level.
function window_planck_taper(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Planck-taper window of length size
function window_rectangular(size_t, ctype_t<T>) Returns template expression that generates a rectangular window of length size
enum window_symmetry Window symmetry mode
function window_triangular(size_t, ctype_t<T>) Returns template expression that generates a triangular window of length size
function window_tukey(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Tukey window of length size (numpy compatible)
enum window_type Window function types supported by KFR
function samplerate_converter<T>::window(fbase) Computes the Kaiser window function for a given sample position.
function window(size_t, cval_t<window_type, type>, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns a window expression of the requested compile-time type
function window(size_t, window_type, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns a type-erased window expression of the requested runtime type

Z¶

variable zpk::z Zeros of the transfer function
struct zpk Zero-pole-gain (ZPK) representation of a linear time-invariant (LTI) filter.

This file was generated by cxxdox, a C++ documentation generator based on MkDocs Material and libclang.