Functions¶

A¶

• 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).
• 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¶

• 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
• 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¶

• 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).
• function cweighting(const T1 &) C-weighting filter response for a scalar frequency.
• function cweighting(E1 &&) C-weighting filter response as an expression.

D¶

• 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.
• 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)
• 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.

E¶

• 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.

F¶

• 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.
• 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.
• 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.
• function fracdelay(E1 &&, T) Returns template expression that applies a fractional delay to the input

G¶

• 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 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¶

• 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.

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.
• 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.
• 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.
• 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.

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.

L¶

• function library_version_dsp() Returns the full version string of the KFR DSP module.
• function loudness_to_energy(T) Inverse of energy_to_loudness : convert LUFS back to linear energy.

M¶

• function make_kfilter(int) Build the EBU R128 K-weighting pre-filter as an IIR expression handle.
• 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.
• 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.
• 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.

N¶

• 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.

P¶

• 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.
• 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).

R¶

• 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.
• function resampler(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>) Helper function to create a sample rate converter instance.
• 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.

S¶

• 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.
• 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.
• 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 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 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 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.
• 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.

T¶

• function to_sos(const zpk &) Converts a zero-pole-gain filter to second-order sections (SOS) form.
• 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.

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.

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
• 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
• 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
• 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)
• 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