fir¶

`fir_lowpass` class (`generic::fn::fir_lowpass`)¶

fir_lowpass

`fir_highpass` class (`generic::fn::fir_highpass`)¶

fir_highpass

`fir_bandpass` class (`generic::fn::fir_bandpass`)¶

fir_bandpass

`fir_bandstop` class (`generic::fn::fir_bandstop`)¶

fir_bandstop

`fir_lowpass` function (`generic::fir_lowpass`)¶

template <typename T, univector_tag Tag>
void fir_lowpass(univector<T, Tag> &taps,
                 std::type_identity_t<T> cutoff,
                 const expression_handle<T> &window,
                 bool normalize = true)

Calculates coefficients for the low-pass FIR filter
Param taps array where computed coefficients are stored
Param cutoff Normalized frequency (frequency_Hz / samplerate_Hz)
Param window pointer to a window function
Param normalize true for normalized coefficients

`fir_highpass` function (`generic::fir_highpass`)¶

template <typename T, univector_tag Tag>
void fir_highpass(univector<T, Tag> &taps,
                  std::type_identity_t<T> cutoff,
                  const expression_handle<T> &window,
                  bool normalize = true)

Calculates coefficients for the high-pass FIR filter
Param taps array where computed coefficients are stored
Param cutoff Normalized frequency (frequency_Hz / samplerate_Hz)
Param window pointer to a window function
Param normalize true for normalized coefficients

`fir_bandpass` function (`generic::fir_bandpass`)¶

template <typename T, univector_tag Tag>
void fir_bandpass(univector<T, Tag> &taps,
                  std::type_identity_t<T> frequency1,
                  std::type_identity_t<T> frequency2,
                  const expression_handle<T> &window,
                  bool normalize = true)

Calculates coefficients for the band-pass FIR filter
Param taps array where computed coefficients are stored
Param frequency1 Normalized frequency (frequency_Hz / samplerate_Hz)
Param frequency2 Normalized frequency (frequency_Hz / samplerate_Hz)
Param window pointer to a window function
Param normalize true for normalized coefficients

`fir_bandstop` function (`generic::fir_bandstop`)¶

template <typename T, univector_tag Tag>
void fir_bandstop(univector<T, Tag> &taps,
                  std::type_identity_t<T> frequency1,
                  std::type_identity_t<T> frequency2,
                  const expression_handle<T> &window,
                  bool normalize = true)

Calculates coefficients for the band-stop FIR filter
Param taps array where computed coefficients are stored
Param frequency1 Normalized frequency (frequency_Hz / samplerate_Hz)
Param frequency2 Normalized frequency (frequency_Hz / samplerate_Hz)
Param window pointer to a window function
Param normalize true for normalized coefficients

`fir_lowpass` function (`generic::fir_lowpass`)¶

template <typename T>
void fir_lowpass(const univector_ref<T> &taps,
                 std::type_identity_t<T> cutoff,
                 const expression_handle<T> &window,
                 bool normalize = true)

@copydoc kfr::fir_lowpass

`fir_highpass` function (`generic::fir_highpass`)¶

template <typename T>
void fir_highpass(const univector_ref<T> &taps,
                  std::type_identity_t<T> cutoff,
                  const expression_handle<T> &window,
                  bool normalize = true)

@copydoc kfr::fir_highpass

`fir_bandpass` function (`generic::fir_bandpass`)¶

template <typename T>
void fir_bandpass(const univector_ref<T> &taps,
                  std::type_identity_t<T> frequency1,
                  std::type_identity_t<T> frequency2,
                  const expression_handle<T> &window,
                  bool normalize = true)

@copydoc kfr::fir_bandpass

`fir_bandstop` function (`generic::fir_bandstop`)¶

template <typename T>
void fir_bandstop(const univector_ref<T> &taps,
                  std::type_identity_t<T> frequency1,
                  std::type_identity_t<T> frequency2,
                  const expression_handle<T> &window,
                  bool normalize = true)

@copydoc kfr::fir_bandstop

`delay_state` class (`generic::delay_state`)¶

template <typename T, size_t samples,
          univector_tag Tag = samples>
delay_state

template <typename T> delay_state

`expression_delay` class (`generic::expression_delay`)¶

template <size_t delay, typename E, bool stateless,
          univector_tag STag>
expression_delay

template <typename E, bool stateless, univector_tag STag>
expression_delay

`delay` function (`generic::delay`)¶

template <size_t samples = 1, typename E1,
          typename T = expression_value_type<E1>>
expression_delay<samples, E1, false, samples> delay(E1 &&e1)

Returns template expression that applies delay to the input (uses ring buffer internally)
Param e1 an input expression
Param samples delay in samples (must be a compile time value)

univector<double, 10\> v = counter();
auto d = delay(v, csize<4\>);

template <size_t samples, typename T, typename E1,
          univector_tag STag>
expression_delay<samples, E1, true, STag>
delay(E1 &&e1,
      std::reference_wrapper<delay_state<T, samples, STag>>
          state)

Returns template expression that applies delay to the input (uses ring buffer in state)
Param state delay filter state (taken by reference)
Param e1 an input expression

univector<double, 10\> v = counter();
delay_state<double, 4\> state;
auto d = delay(state, v);

template <size_t samples, typename T, typename E1,
          univector_tag STag>
[[deprecated("delay(state, expr) is deprecated. Use "
             "delay(expr, std::ref(state))")]]
expression_delay<samples, E1, true, STag>
delay(delay_state<T, samples, STag> &state, E1 &&e1)

Returns template expression that applies delay to the input (uses ring buffer in state)
Param state delay filter state
Param e1 an input expression

univector<double, 10\> v = counter();
delay_state<double, 4\> state;
auto d = delay(state, v);

`fracdelay` function (`generic::fracdelay`)¶

template <typename T, typename E1>
expression_short_fir<2, T, expression_value_type<E1>, E1>
fracdelay(E1 &&e1, T delay)

Returns template expression that applies a fractional delay to the input
Param e1 an input expression
Param e1 a fractional delay in range 0..1

`short_fir_state` class¶

template <size_t tapcount, typename T, typename U = T>
short_fir_state

`fir_params` class¶

template <typename T> fir_params

`fir_state` class¶

template <typename T, typename U = T> fir_state

`moving_sum_state` class¶

template <typename U,
          univector_tag Tag = tag_dynamic_vector>
moving_sum_state

template <typename U> moving_sum_state

`expression_short_fir` class (`generic::expression_short_fir`)¶

template <size_t tapcount, typename T, typename U,
          typename E1, bool stateless = false>
expression_short_fir

`expression_fir` class (`generic::expression_fir`)¶

template <typename T, typename U, typename E1,
          bool stateless = false>
expression_fir

`expression_moving_sum` class (`generic::expression_moving_sum`)¶

template <typename U, typename E1, univector_tag STag,
          bool stateless = false>
expression_moving_sum

`fir` function (`generic::fir`)¶

template <typename E1, typename U = expression_value_type<E1>, typename Taps,
          typename T = std::remove_cv_t<container_value_type<Taps>>>
[[deprecated("fir(expr, taps) is deprecated. Use fir(expr, fir_params

Returns template expression that applies FIR filter to the input
Param e1 an input expression
Param taps coefficients for the FIR filter (taken by value)

template <typename T, typename E1,
          typename U = expression_value_type<E1>>
expression_fir<T, U, E1, false> fir(E1 &&e1,
                                    fir_params<T> state)

Returns template expression that applies FIR filter to the input
Param e1 an input expression
Param state coefficients for the FIR filter (taken by value)

template <typename T, typename E1, typename U>
expression_fir<T, U, E1, true>
fir(E1 &&e1, std::reference_wrapper<fir_state<T, U>> state)

Returns template expression that applies FIR filter to the input
Param e1 an input expression
Param state coefficients and state of the filter (taken by reference, ensure proper lifetime)

template <typename T, typename U, typename E1>
[[deprecated(
    "fir(state, expr) is deprecated. Use fir(expr, "
    "std::ref(state))")]] expression_fir<T, U, E1, true>
fir(fir_state<T, U> &state, E1 &&e1)

Returns template expression that applies FIR filter to the input
Param state FIR filter state (state is referenced, ensure proper lifetime)
Param e1 an input expression

`moving_sum` function (`generic::moving_sum`)¶

template <typename E1>
expression_moving_sum<expression_value_type<E1>, E1,
                      tag_dynamic_vector>
moving_sum(E1 &&e1, size_t sum_length)

Returns template expression that performs moving sum on the input
Param e1 an input expression

template <size_t sum_length, typename E1>
[[deprecated("moving_sum<len> is deprecated. Use "
             "moving_sum(expr, len) instead")]]
expression_moving_sum<expression_value_type<E1>, E1,
                      tag_dynamic_vector>
moving_sum(E1 &&e1)

Returns template expression that performs moving sum on the input
Param e1 an input expression

template <typename E1, typename U, size_t Tag>
expression_moving_sum<U, E1, Tag, true> moving_sum(
    E1 &&e1,
    std::reference_wrapper<moving_sum_state<U, Tag>> state)

Returns template expression that performs moving sum on the input
Param e1 an input expression
Param state State (taken by reference)

template <typename U, typename E1, univector_tag STag>
[[deprecated(
    "moving_sum(state, expr) is deprecated. Use "
    "moving_sum(expr, std::ref(state)) "
    "instead")]] expression_moving_sum<U, E1, STag, true>
moving_sum(moving_sum_state<U, STag> &state, E1 &&e1)

Returns template expression that performs moving sum on the input
Param state moving sum state
Param e1 an input expression

`short_fir` function (`generic::short_fir`)¶

template <typename T, size_t TapCount, typename E1,
          size_t InternalTapCount =
              next_poweroftwo(TapCount - 1) + 1,
          typename U = expression_value_type<E1>>
expression_short_fir<InternalTapCount, T, U, E1, false>
short_fir(E1 &&e1, const univector<T, TapCount> &taps)

Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
Param e1 an input expression
Param taps coefficients for the FIR filter

template <typename T, size_t TapCount, typename E1,
          typename U>
expression_short_fir<TapCount, T, U, E1, true> short_fir(
    E1 &&e1,
    std::reference_wrapper<short_fir_state<TapCount, T, U>>
        state)

Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
Param e1 an input expression
Param state FIR filter state (state is referenced, ensure proper lifetime)

template <size_t TapCount,
          size_t InternalTapCount =
              next_poweroftwo(TapCount - 1) + 1,
          typename T, typename U, typename E1>
[[deprecated("short_fir(state, expr) is deprecated, use "
             "short_fir(expr, std::ref(state))")]]
expression_short_fir<InternalTapCount, T,
                     expression_value_type<E1>, E1, true>
short_fir(short_fir_state<InternalTapCount, T, U> &state,
          E1 &&e1)

Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
Param state FIR filter state
Param e1 an input expression

`fir_filter` class¶

template <typename T, typename U = T> fir_filter

`reset` function (`fir_filter::reset`)¶

void reset() final

Reset internal filter state

Auto-generated from sources, Revision , https://github.com/kfrlib/kfr/blob//include/kfr/

fir¶

fir_lowpass class (generic::fn::fir_lowpass)¶

fir_highpass class (generic::fn::fir_highpass)¶

fir_bandpass class (generic::fn::fir_bandpass)¶

fir_bandstop class (generic::fn::fir_bandstop)¶

fir_lowpass function (generic::fir_lowpass)¶

fir_highpass function (generic::fir_highpass)¶

fir_bandpass function (generic::fir_bandpass)¶

fir_bandstop function (generic::fir_bandstop)¶

fir_lowpass function (generic::fir_lowpass)¶

fir_highpass function (generic::fir_highpass)¶

fir_bandpass function (generic::fir_bandpass)¶

fir_bandstop function (generic::fir_bandstop)¶

delay_state class (generic::delay_state)¶

expression_delay class (generic::expression_delay)¶

delay function (generic::delay)¶

fracdelay function (generic::fracdelay)¶

short_fir_state class¶

fir_params class¶

fir_state class¶

moving_sum_state class¶

expression_short_fir class (generic::expression_short_fir)¶

expression_fir class (generic::expression_fir)¶

expression_moving_sum class (generic::expression_moving_sum)¶

fir function (generic::fir)¶

moving_sum function (generic::moving_sum)¶

short_fir function (generic::short_fir)¶

fir_filter class¶

reset function (fir_filter::reset)¶

`fir_lowpass` class (`generic::fn::fir_lowpass`)¶

`fir_highpass` class (`generic::fn::fir_highpass`)¶

`fir_bandpass` class (`generic::fn::fir_bandpass`)¶

`fir_bandstop` class (`generic::fn::fir_bandstop`)¶

`fir_lowpass` function (`generic::fir_lowpass`)¶

`fir_highpass` function (`generic::fir_highpass`)¶

`fir_bandpass` function (`generic::fir_bandpass`)¶

`fir_bandstop` function (`generic::fir_bandstop`)¶

`fir_lowpass` function (`generic::fir_lowpass`)¶

`fir_highpass` function (`generic::fir_highpass`)¶

`fir_bandpass` function (`generic::fir_bandpass`)¶

`fir_bandstop` function (`generic::fir_bandstop`)¶

`delay_state` class (`generic::delay_state`)¶

`expression_delay` class (`generic::expression_delay`)¶

`delay` function (`generic::delay`)¶

`fracdelay` function (`generic::fracdelay`)¶

`short_fir_state` class¶

`fir_params` class¶

`fir_state` class¶

`moving_sum_state` class¶

`expression_short_fir` class (`generic::expression_short_fir`)¶

`expression_fir` class (`generic::expression_fir`)¶

`expression_moving_sum` class (`generic::expression_moving_sum`)¶

`fir` function (`generic::fir`)¶

`moving_sum` function (`generic::moving_sum`)¶

`short_fir` function (`generic::short_fir`)¶

`fir_filter` class¶

`reset` function (`fir_filter::reset`)¶