Functions¶

A¶

• function kfr::generic::abs(const T1 &) Returns the absolute value of x.
• function kfr::generic::abs(E1 &&) Returns template expression that returns the absolute value of x.
• function kfr::generic::absmax(E1 &&, E2 &&) Returns the greater in magnitude of two values. Accepts and returns expressions.
• function kfr::generic::absmaxof(const E1 &) Returns the greatest in magnitude of all the elements in x.
• function kfr::generic::absmin(E1 &&, E2 &&) Returns the smaller in magnitude of two values. Accepts and returns expressions.
• function kfr::generic::absminof(const E1 &) Returns the smallest in magnitude of all the elements in x.
• function kfr::compiletime::abs(T)
• function kfr::generic::acos(const T1 &) Returns the arc cosine of x. The returned angle is in the range 0 through \(\pi\) .
• function kfr::acos(E1 &&) Returns template expression that returns the arc cosine of x.
• function kfr::generic::add(E &&...) Returns template expression that returns sum of all the arguments passed to a function.
• function kfr::generic::adjacent(Fn &&, E1 &&) Returns template expression that returns the result of calling \(fn(x_i, x_{i-1})\)
• function kfr::aligned_allocate(size_t) Allocates aligned memory
• function kfr::aligned_allocate(size_t, size_t) Allocates aligned memory
• function kfr::aligned_deallocate(T *) Deallocates aligned memory
• function kfr::generic::all(const mask<T, N> &) Returns true if all elements are true.
• function kfr::generic::amp_to_dB(const T1 &)
• function kfr::generic::amp_to_dB(E1 &&)
• function kfr::generic::any(const mask<T, N> &) Returns true if any element is true.
• function kfr::arange(T, cbool_t<truncated>)
• function kfr::arange(T, T, T, cbool_t<truncated>)
• function kfr::arrangement_for_channels(size_t) Returns a predefined speaker arrangement for a given number of channels If no predefined arrangement exists, returns speaker_arrangement::None
• function kfr::arrangement_speakers(speaker_arrangement) Returns the canonical channel list for a speaker arrangement.
• function kfr::generic::asin(const T1 &) Returns the arc sine of x. The returned angle is in the range \(-\pi/2\) through \(\pi/2\) .
• function kfr::asin(E1 &&) Returns template expression that returns the arc sine of x.
• function kfr::assertion_failed(const std::string &, const char *, int)
• function kfr::atan2deg(E1 &&, E2 &&) Returns template expression that returns the arc tangent of y/x (expressed in degrees).
• function kfr::atan2(E1 &&, E2 &&) Returns template expression that returns the arc tangent of y/x.
• function kfr::atandeg(E1 &&) Returns template expression that returns the arc tangent of the x, expressed in degrees.
• function kfr::atan(E1 &&) Returns template expression that returns the arc tangent of x.
• function kfr::audio_sample_bit_depth(audio_sample_type)
• function kfr::audio_sample_is_float(audio_sample_type)
• function kfr::audio_sample_sizeof(audio_sample_type)
• function kfr::audiofile_container_from_extension(std::string_view) Determines the audio container type from a file extension.
• function kfr::autocorrelate(const univector<T, Tag1> &) Auto-correlation
• function kfr::generic::aweighting(const T1 &)
• function kfr::generic::aweighting(E1 &&)

B¶

• function kfr::generic::begin_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>)
• function kfr::generic::begin_pass(const expression_iir<1, T, E1, Stateless> &, shape<1>, shape<1>)
• function kfr::generic::begin_pass(const expression_iir<filters, T, E1, Stateless> &, shape<1>, shape<1>)
• function kfr::generic::begin_pass(const expression_with_arguments<Args...> &, shape<Dims>, shape<Dims>)
• function kfr::generic::begin_pass(const internal_generic::anything &, shape<Dims>, shape<Dims>)
• function kfr::generic::bessel(int)
• function kfr::generic::bind_expression(Fn &&, Args &&...)
• function kfr::generic::biquad_allpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the all-pass biquad filter
• function kfr::generic::biquad_bandpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the band-pass biquad filter
• function kfr::generic::biquad_highpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-pass biquad filter
• function kfr::generic::biquad_highshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-shelf biquad filter
• function kfr::generic::biquad_lowpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-pass biquad filter
• function kfr::generic::biquad_lowshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-shelf biquad filter
• function kfr::generic::biquad_notch(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the notch biquad filter
• function kfr::generic::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 kfr::generic::bitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the bits of their indices.
• function kfr::generic::bitreverse(u32) Reverses the lowest bits bits of the given unsigned integer.
• function kfr::generic::block_process(size_t, csizes_t<widths...>, Fn &&)
• function kfr::generic::butterworth(int)
• function kfr::generic::bweighting(const T1 &)
• function kfr::generic::bweighting(E1 &&)

C¶

• function kfr::generic::cabs(const T1 &) Returns the absolute value (magnitude) of the complex number x
• function kfr::cabs(E1 &&) Returns template expression that returns the absolute value (magnitude) of the complex number x
• function kfr::generic::cabssqr(const T1 &) Returns the squared absolute value (magnitude squared) of the complex number x
• function kfr::cabssqr(E1 &&) Returns template expression that returns the squared absolute value (magnitude squared) of the complex number x
• function kfr::call_with_temp(size_t, Fn &&) Calls a function with a temporary buffer, allocated on the stack if small enough, otherwise on the heap.
• function kfr::generic::carg(const T1 &) Returns the phase angle (argument) of the complex number x
• function kfr::carg(E1 &&) Returns template expression that returns the phase angle (argument) of the complex number x
• function kfr::generic::cartesian(const T1 &) Converts complex number to cartesian
• function kfr::cartesian(E1 &&) Returns template expression that converts complex number to cartesian
• function kfr::cast(Arg &&)
• function kfr::cast(Arg &&, ctype_t<T>)
• function kfr::generic::catmullrom(M, T, T, T, T) Catmull-Rom spline interpolation.
• function kfr::cbrt(E1 &&) Returns the cube root of the x. Accepts and returns expressions.
• function kfr::generic::ccomp(const vec<T, N> &)
• function kfr::generic::cconj(const T1 &) Returns the complex conjugate of the complex number x
• function kfr::generic::cconj(E1 &&) Returns template expression that returns the complex conjugate of the complex number x
• function kfr::generic::ccos(const T1 &) Returns the cosine of the complex number x
• function kfr::ccos(E1 &&) Returns template expression that returns the cosine of the the complex value x
• function kfr::generic::ccosh(const T1 &) Returns the hyperbolic cosine of the complex number x
• function kfr::ccosh(E1 &&) Returns template expression that returns the hyperbolic cosine of the the complex value x
• function kfr::generic::cdecom(const vec<complex<T>, N> &)
• function kfr::generic::cdupimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part duplicated
• function kfr::generic::cdupreal(const vec<complex<T>, N> &) Returns vector of complex values with real part duplicated
• function kfr::generic::ceil(const T1 &) Returns the smallest integer value not less than x.
• function kfr::generic::ceil(E1 &&)
• function kfr::generic::cexp10(const T1 &) Returns 10 raised to the complex number x
• function kfr::cexp10(E1 &&) Returns template expression that returns 10 raised to the complex number x
• function kfr::generic::cexp2(const T1 &) Returns 2 raised to the complex number x
• function kfr::cexp2(E1 &&) Returns template expression that returns 2 raised to the complex number x
• function kfr::generic::cexp(const T1 &) Returns \(e\) raised to the complex number x
• function kfr::cexp(E1 &&) Returns template expression that returns \(e\) raised to the complex number x
• function kfr::cforeach(const std::tuple<Ts...> &, Fn &&)
• function kfr::generic::chebyshev1(int, double)
• function kfr::generic::chebyshev2(int, double)
• function kfr::check_assertion(...)
• function kfr::check_assertion(const comparison<Op, L, R> &, const char *, const char *, int)
• function kfr::check_assertion(const half_comparison<L> &, const char *, const char *, int)
• function kfr::generic::clamp(const T1 &, const T2 &) Returns the first argument clamped to a range [0, hi]
• function kfr::generic::clamp(const T1 &, const T2 &, const T3 &) Returns the first argument clamped to a range [lo, hi]
• function kfr::generic::clamp(E1 &&, E2 &&) Creates an expression that returns the first argument clamped to a range [0, hi]
• function kfr::generic::clamp(E1 &&, E2 &&, E3 &&) Creates an expression that returns the first argument clamped to a range [lo, hi]
• function kfr::generic::clog10(const T1 &) Returns the common (base-10) logarithm of the complex number x
• function kfr::clog10(E1 &&) Returns template expression that returns the common (base-10) logarithm of the complex number x
• function kfr::generic::clog2(const T1 &) Returns the binary (base-2) logarithm of the complex number x
• function kfr::clog2(E1 &&) Returns template expression that returns the binary (base-2) logarithm of the complex number x
• function kfr::generic::clog(const T1 &) Returns the natural logarithm of the complex number x
• function kfr::clog(E1 &&) Returns template expression that returns the natural logarithm of the complex number x
• function kfr::generic::cnegimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part negated
• function kfr::generic::cnegreal(const vec<complex<T>, N> &) Returns vector of complex values with real part negated
• function kfr::concat_args()
• function kfr::concat_args(const std::string &, const Ts &...)
• function kfr::concatenate(Arg1 &&, Arg2 &&)
• function kfr::concatenate(Arg1 &&, Arg2 &&, Arg3 &&)
• function kfr::convert_endianness(T *, size_t)
• function kfr::generic::convert_sample(const Tin &)
• function kfr::generic::convert(Tout *, const Tin *, size_t) Converts audio samples (both formats are known at compile time)
• function kfr::generic::convert(Tout *, const void *, audio_sample_type, size_t) Converts audio samples (input format is known at runtime)
• function kfr::generic::convert(void *, audio_sample_type, const Tin *, size_t) Converts audio samples (output format is known at runtime)
• function kfr::convolve(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Convolution
• function kfr::correlate(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Correlation
• function kfr::cosdeg(E1 &&) Returns the trigonometric cosine of the x (expressed in degrees). Accepts and returns expressions.
• function kfr::cos(E1 &&) Returns the trigonometric cosine of x. Accepts and returns expressions.
• function kfr::generic::cosh(const T1 &) Returns the hyperbolic cosine of the x
• function kfr::cosh(E1 &&) Returns template expression that returns the hyperbolic cosine of the x
• function kfr::generic::coshsinh(const T1 &) Returns the hyperbolic cosine of the even elements of the x and the hyperbolic sine of the odd elements of the x
• function kfr::coshsinh(E1 &&) Returns template expression that returns the hyperbolic cosine of the even elements of the x and the hyperbolic sine of the odd elements of the x
• function kfr::generic::cosine(M, T, T) Cosine interpolation.
• function kfr::cossindeg(E1 &&) Returns the trigonometric cosine of the even elements of the x and sine of the odd elements. x must be expressed in degrees. Accepts and returns expressions.
• function kfr::cossin(E1 &&) Returns the trigonometric cosine of the even elements of the x and sine of the odd elements. x must be a vector. Accepts and returns expressions.
• function kfr::compiletime::cos(T)
• function kfr::generic::coth(const T1 &) Returns the hyperbolic cotangent of the x
• function kfr::coth(E1 &&) Returns template expression that returns the hyperbolic cotangent of the x
• function kfr::counter(T)
• function kfr::counter(T, Arg, Args...)
• function kfr::create_aiff_decoder(const aiff_decoding_options &) Creates a decoder for AIFF audio files.
• function kfr::create_aiff_encoder(const aiff_encoding_options &) Creates an AIFF audio encoder with optional encoding options.
• function kfr::create_caff_decoder(const caff_decoding_options &) Creates a decoder for CAFF audio files.
• function kfr::create_caff_encoder(const caff_encoding_options &) Creates a CAFF audio encoder with optional encoding options.
• function kfr::create_decoder_for_container(audiofile_container, const audio_decoding_options &) Creates an audio decoder for a specific container type.
• function kfr::create_decoder_for_file(const file_path &, const audio_decoding_options &) Creates an audio decoder for a file.
• function kfr::create_decoder_for_file(const std::string &, const audio_decoding_options &) file_path&, const audio_decoding_options&)
• function kfr::create_decoder_from_header(const audiofile_header &, const audio_decoding_options &) Creates an audio decoder from a file header.
• function kfr::create_encoder_for_container(audiofile_container, const audio_encoding_options &) Creates an audio encoder for the specified container format with optional encoding options.
• function kfr::create_mediafoundation_decoder(const mediafoundation_decoding_options &) Creates a Media Foundation-based audio decoder.
• function kfr::create_mp3_decoder(const mp3_decoding_options &) Creates an MP3 audio decoder with the specified decoding options.
• function kfr::create_raw_decoder(const raw_decoding_options &) Creates a decoder for raw audio streams.
• function kfr::create_raw_encoder(const raw_encoding_options &) Creates a raw audio encoder with optional encoding options.
• function kfr::create_w64_decoder(const w64_decoding_options &) Creates a decoder for W64 audio files.
• function kfr::create_w64_encoder(const w64_encoding_options &) Creates a W64 audio encoder with optional encoding options.
• function kfr::create_wave_decoder(const wave_decoding_options &) Creates a decoder for WAVE audio files.
• function kfr::create_wave_encoder(const wave_encoding_options &) Creates a WAVE audio encoder with optional encoding options.
• function kfr::generic::csin(const T1 &) Returns the sine of the complex number x
• function kfr::csin(E1 &&) Returns template expression that returns the sine of the the complex value x
• function kfr::generic::csinh(const T1 &) Returns the hyperbolic sine of the complex number x
• function kfr::csinh(E1 &&) Returns template expression that returns the hyperbolic sine of the complex number x
• function kfr::generic::csqr(const T1 &) Returns square of the complex number x
• function kfr::csqr(E1 &&) Returns template expression that returns square of the complex number x
• function kfr::generic::csqrt(const T1 &) Returns square root of the complex number x
• function kfr::csqrt(E1 &&) Returns template expression that returns square root of the complex number x
• function kfr::generic::cswapreim(const vec<complex<T>, N> &) Returns vector of complex values with real and imaginary parts swapped
• function kfr::generic::cub(E1 &&) Returns template expression that returns cube of x.
• function kfr::generic::cubic(M, T, T, T, T) Cubic interpolation.
• function kfr::current_epsilon()
• function kfr::generic::cweighting(const T1 &)
• function kfr::generic::cweighting(E1 &&)

D¶

• function kfr::generic::dB_to_amp(const T1 &)
• function kfr::generic::dB_to_amp(E1 &&)
• function kfr::generic::dB_to_power(const T1 &)
• function kfr::generic::dB_to_power(E1 &&)
• function kfr::dB_to_string(const T &, double) Converts dB value to string (uses oo for infinity symbol)
• function kfr::dB_to_utf8string(const T &, double) Converts dB value to string (uses infinity symbol in utf-8 encoding)
• function kfr::dcremove(E1 &&, double)
• function kfr::dcremove(E1 &&, double, double) Applies a DC removal filter to the given input expression.
• function kfr::decode_audio_file(const file_path &, audiofile_format *, const audio_decoding_options &) Decodes an audio file and returns the audio data in an interleaved format.
• function kfr::decode_audio_file(const std::string &, audiofile_format *, const audio_decoding_options &)
• function kfr::deep_is_equal(const T1 &, const T2 &)
• function kfr::generic::deinterleave(Tout **, const Tin *, size_t, size_t) Deinterleaves and converts audio samples
• function kfr::generic::deinterleave(univector2d<Tout, Tag1, Tag2> &, const univector<Tin, Tag3> &) Deinterleaves and converts audio samples
• function kfr::generic::delay(delay_state<T, samples, STag> &, E1 &&) Returns template expression that applies delay to the input (uses ring buffer in state)
• function kfr::generic::delay(E1 &&) Returns template expression that applies delay to the input (uses ring buffer internally)
• function kfr::generic::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 kfr::generic::dft(const univector<complex<T>, Tag> &) Performs Direct DFT using cached plan
• function kfr::generic::digitreverse4(const vec<T, N> &) Reorders the elements of a vector by reversing base-4 (quaternary) digits of their indices.
• function kfr::generic::digitreverse4(u32) Reverses the digits of the given unsigned integer in base-4 (quaternary), using the lowest bits digits.
• function kfr::generic::digitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the digits of their indices in the specified radix.
• function kfr::generic::dimensions(E1 &&) Returns template expression with gien number of dimensions
• function kfr::generic::dotproduct(E1 &&, E2 &&) Returns the dot product of two vectors.
• function kfr::generic::downsample2(E1 &&, csize_t<offset>)
• function kfr::generic::downsample4(E1 &&, csize_t<offset>)

E¶

• function kfr::element_size()
• function kfr::element_size<>()
• function kfr::encode_audio_file(const file_path &, const audio_data_interleaved &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes interleaved audio data and writes it to a file.
• function kfr::encode_audio_file(const file_path &, const audio_data_planar &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes planar audio data and writes it to a file.
• function kfr::encode_audio_file(const std::string &, const audio_data_interleaved &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes interleaved audio data and writes it to a file (Windows-specific overload).
• function kfr::encode_audio_file(const std::string &, const audio_data_planar &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes planar audio data and writes it to a file (Windows-specific overload).
• function kfr::generic::end_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>)
• function kfr::generic::end_pass(const expression_iir<1, T, E1, Stateless> &, shape<1>, shape<1>)
• function kfr::generic::end_pass(const expression_iir<filters, T, E1, Stateless> &, shape<1>, shape<1>)
• function kfr::generic::end_pass(const expression_with_arguments<Args...> &, shape<Dims>, shape<Dims>)
• function kfr::generic::end_pass(const internal_generic::anything &, shape<Dims>, shape<Dims>)
• function kfr::generic::energy_to_loudness(T)
• function kfr::generic::eq(E1 &&, E2 &&)
• function kfr::generic::equal(const T1 &, const T2 &)
• function kfr::exp10(E1 &&) Returns 10 raised to the given power x. Accepts and returns expressions.
• function kfr::exp2(E1 &&) Returns 2 raised to the given power x. Accepts and returns expressions.
• function kfr::exp_fmadd(E1 &&, E2 &&, E3 &&) Returns exp(x * m + a). Accepts and returns expressions.
• function kfr::exp(E1 &&) Returns e raised to the given power x. Accepts and returns expressions.

F¶

• function kfr::generic::factorial_approx(const T1 &) Returns the approximate factorial of an argument
• function kfr::factorial_approx(E1 &&) Creates expression that returns the approximate factorial of an argument
• function kfr::generic::factorial(int) Returns the factorial of an argument. Returns max(uint64_t) if does not fit to uint64_t
• function kfr::fastcosdeg(E1 &&) Returns an approximation of the trigonometric cosine of the x (expressed in degrees). Accepts and returns expressions.
• function kfr::fastcos(E1 &&) Returns an approximation of the trigonometric cosine of x. Accepts and returns expressions.
• function kfr::fastsindeg(E1 &&) Returns an approximation of the trigonometric sine of the x (expressed in degrees). Accepts and returns expressions.
• function kfr::fastsin(E1 &&) Returns an approximation of the trigonometric sine of x. Accepts and returns expressions.
• function kfr::generic::fft_multiply_accumulate(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, const univector<complex<T>, Tag3> &, const univector<complex<T>, Tag4> &, dft_pack_format)
• function kfr::generic::fft_multiply_accumulate(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, const univector<complex<T>, Tag3> &, dft_pack_format)
• function kfr::generic::fft_multiply(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, const univector<complex<T>, Tag3> &, dft_pack_format)
• function kfr::file_extension(const file_path &)
• function kfr::generic::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 kfr::generic::final_mean(T, size_t)
• function kfr::generic::final_rootmean(T, size_t)
• function kfr::generic::fir_bandpass(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
• function kfr::generic::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
• function kfr::generic::fir_bandstop(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
• function kfr::generic::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 FIR filter
• function kfr::generic::fir_highpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
• function kfr::generic::fir_highpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the high-pass FIR filter
• function kfr::generic::fir_lowpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
• function kfr::generic::fir_lowpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the low-pass FIR filter
• function kfr::generic::fir(E1 &&, fir_params<T>) Returns template expression that applies FIR filter to the input
• function kfr::generic::fir(E1 &&, std::reference_wrapper<fir_state<T, U>>) Returns template expression that applies FIR filter to the input
• function kfr::generic::fir(E1 &&, Taps &&) Returns template expression that applies FIR filter to the input
• function kfr::generic::fir(fir_state<T, U> &, E1 &&) Returns template expression that applies FIR filter to the input
• function kfr::fixshape(Arg &&, const fixed_shape_t<ShapeValues...> &)
• function kfr::generic::floor(const T1 &) Returns the largest integer value not greater than x.
• function kfr::generic::floor(E1 &&) Returns the largest integer value not greater than x. Accepts and returns expressions.
• function kfr::generic::fmod(const T &, const T &) Returns the floating-point remainder of dividing x by y.
• function kfr::fopen_path(const file_path &, open_file_mode)
• function kfr::generic::fracdelay(E1 &&, T) Returns template expression that applies a fractional delay to the input
• function kfr::generic::fract(const T1 &) Returns the fractional part of x.
• function kfr::generic::fract(E1 &&)
• function kfr::from_error_code(std::error_code) Converts a standard error code to an audiofile_error.

G¶

• function kfr::generic::gamma(const T1 &) Returns the approximate gamma function of an argument
• function kfr::gamma(E1 &&) Creates expression that returns the approximate gamma function of an argument
• function kfr::generic::gather_stride(const T *)
• function kfr::generic::gather_stride(const T *, size_t)
• function kfr::generic::gather(const T *)
• function kfr::generic::gather(const T *, const vec<IT, N> &)
• function kfr::generic::gather(const T *, const vec<u32, N> &)
• function kfr::generic::gather(const T *, size_t, Indices...)
• function kfr::generic::ge(E1 &&, E2 &&)
• function kfr::generic::gen_cossin(T1, T2) Returns template expression that generates values using the following formula:
  \[ x_i= \begin{cases} \cos(start + i \cdot step), & \text{if } i \text{ is even}\ \sin(start + i \cdot step), & \text{otherwise} \end{cases} \]
• function kfr::generic::gen_exp2(T1, T2) Returns template expression that generates values using the following formula:
  \[ x_i = 2^{ start + i \cdot step } \]
• function kfr::generic::gen_expj(T1, T2) Returns template expression that generates values using the following formula:
  \[ x_i = e^{ j ( start + i \cdot step ) } \]
• function kfr::generic::gen_exp(T1, T2) Returns template expression that generates values using the following formula:
  \[ x_i = e^{ start + i \cdot step } \]
• function kfr::generic::gen_linear(T1, T2) Returns template expression that generates values starting from the start and using the step as the increment between numbers.
• function kfr::generic::gen_random_normal(const random_state &, T, T) Returns expression that produces normally distributed values using a copied state.
• function kfr::generic::gen_random_normal(std::reference_wrapper<random_state>, T, T) Returns expression that produces normally distributed values using a referenced state.
• function kfr::generic::gen_random_normal(T, T) Returns expression that produces normally distributed values using cycle counter entropy.
• function kfr::generic::gen_random_range(const random_state &, T, T) Returns expression that produces random values in [min, max) using a copied state.
• function kfr::generic::gen_random_range(std::reference_wrapper<random_state>, T, T) Returns expression that produces random values in [min, max) using a referenced state. Use std::ref(gen) to use this overload.
• function kfr::generic::gen_random_range(T, T) Returns expression that produces random values in [min, max) using cycle counter entropy
• function kfr::generic::gen_random_uniform() Returns expression that produces uniform pseudorandom values using cycle counter entropy.
• function kfr::generic::gen_random_uniform(const random_state &) Returns expression that produces uniform pseudorandom values using a copied state.
• function kfr::generic::gen_random_uniform(std::reference_wrapper<random_state>) Returns expression that produces uniform pseudorandom values using a referenced state. Use std::ref(gen) to use this overload.
• function kfr::generic::gen_sin(T1, T2) Returns template expression that generates values using the following formula:
  \[ x_i = \sin( start + i \cdot step ) \]
• function kfr::get_element(E &&, shape<Dims>)
• function kfr::generic::get_elements(const expression_cast<T, Arg> &, const shape<NDims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_concatenate<Arg1, Arg2, ConcatAxis> &, const shape<NDims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_counter<T, 1> &, const shape<1> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_counter<T, dims> &, const shape<dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_fixshape<Arg, Shape> &, const shape<Traits::dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_function<Fn, Args...> &, const shape<Dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_handle<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_iir<1, T, E1, Stateless> &, shape<1>, axis_params<0, N>)
• function kfr::generic::get_elements(const expression_iir_l<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>)
• function kfr::generic::get_elements(const expression_iir<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>)
• function kfr::generic::get_elements(const expression_lambda<T, Dims, Fn, Rnd> &, const shape<Dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_linspace<T, truncated> &, const shape<1> &, const axis_params<0, N> &)
• function kfr::generic::get_elements(const expression_padded<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_placeholder<T, Dims, Key> &, shape<Dims>, axis_params<VecAxis, N>)
• function kfr::generic::get_elements(const expression_reshape<Arg, outdims> &, const shape<Traits::dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_reverse<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_scalar<T> &, const shape<0> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const expression_slice<Arg> &, const shape<NDims> &, const axis_params<Axis, N> &)
• function kfr::get_elements(const strided_channel<T> &, const shape<1> &, const axis_params<0, N> &)
• function kfr::generic::get_elements(const tensor<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &)
• function kfr::generic::get_elements(const univector<T, Tag> &, const shape<1> &, const axis_params<0, N> &)
• function kfr::generic::get_elements(T &&, const shape<0> &, const axis_params<Axis, N> &)
• function kfr::get_shape()
• function kfr::get_shape(T &&)
• function kfr::generic::goertzel(complex<T> &, std::type_identity_t<T>)
• function kfr::generic::goertzel(complex<T> (&)[width], const T (&)[width])
• function kfr::generic::greater(const T1 &, const T2 &)
• function kfr::generic::greaterorequal(const T1 &, const T2 &)
• function kfr::generic::gt(E1 &&, E2 &&)

H¶

• function kfr::generic::hadd(const vec<T, N> &) Computes the sum of all elements in the vector.
• function kfr::generic::havg(const vec<T, N> &) Computes the arithmetic mean (average) of all elements in the vector.
• function kfr::generic::hbitwiseand(const vec<T, N> &) Computes the bitwise AND of all elements in the vector.
• function kfr::generic::hbitwiseor(const vec<T, N> &) Computes the bitwise OR of all elements in the vector.
• function kfr::generic::hbitwisexor(const vec<T, N> &) Computes the bitwise XOR of all elements in the vector.
• function kfr::generic::hdot(const vec<T, N> &, const vec<T, N> &) Computes the dot product of two vectors.
• function kfr::generic::hertz_to_note(const T1 &)
• function kfr::generic::hertz_to_note(E1 &&)
• function kfr::generic::histogram_expression(E &&) Returns expression that computes histogram as data flows through it. Number of bins defined at compile time
• function kfr::generic::histogram_expression(E &&, size_t) Returns expression that computes histogram as data flows through it. Number of bins defined at runtime
• function kfr::generic::histogram(E &&) Returns histogram of the expression data. Number of bins defined at compile time
• function kfr::generic::histogram(E &&, size_t) Returns histogram of the expression data. Number of bins defined at runtime
• function kfr::generic::hmax(const vec<T, N> &) Computes the maximum element in the vector.
• function kfr::generic::hmin(const vec<T, N> &) Computes the minimum element in the vector.
• function kfr::generic::hmul(const vec<T, N> &) Computes the product of all elements in the vector.
• function kfr::generic::horizontal(const vec<T, N> &, ReduceFn &&) Applies a reduction function horizontally across all elements of the vector.
• function kfr::generic::horner_even(E &&...)
• function kfr::generic::horner_odd(E &&...)
• function kfr::generic::horner(E &&...)
• function kfr::generic::hproduct(const vec<T, N> &) Computes the product of all elements in the vector.
• function kfr::generic::hrms(const vec<T, N> &) Computes the root-mean-square (RMS) of the vector elements.
• function kfr::generic::hsum(const vec<T, N> &) Computes the sum of all elements in the vector.

I¶

• function kfr::generic::iceil(const T1 &) Returns the smallest integer value not less than x, as an integer type.
• function kfr::generic::iceil(E1 &&)
• function kfr::generic::idft(const univector<complex<T>, Tag> &) Performs Inverse DFT using cached plan
• function kfr::generic::ifloor(const T1 &) Returns the largest integer value not greater than x, as an integer type.
• function kfr::generic::ifloor(E1 &&)
• function kfr::generic::iir_bandpass(const zpk &, double, double, double) Calculates zero-pole-gain coefficients for the band-pass IIR filter
• function kfr::generic::iir_bandstop(const zpk &, double, double, double) Calculates zero-pole-gain coefficients for the band-stop IIR filter
• function kfr::generic::iir_highpass(const zpk &, double, double) Calculates zero-pole-gain coefficients for the high-pass IIR filter
• function kfr::generic::iir_lowpass(const zpk &, double, double) Calculates zero-pole-gain coefficients for the low-pass IIR filter
• function kfr::generic::iir(E1 &&, const iir_params<T, tag_dynamic_vector> &) Returns template expressions that applies biquad filter to the input.
• function kfr::generic::iir(E1 &&, const zpk &) Returns template expressions that applies biquad filter to the input.
• function kfr::generic::iir(E1 &&, iir_params<T, filters>) Returns template expressions that applies biquad filter to the input.
• function kfr::generic::iir(E1 &&, std::reference_wrapper<iir_state<T, filters>>) Returns template expressions that applies biquad filter to the input.
• function kfr::generic::imag(const complex<T> &) Returns the imaginary part of the complex value
• function kfr::generic::imag(const vec<complex<T>, N> &) Returns the imaginary part of the complex value
• function kfr::generic::imag(E1 &&) Returns the imaginary part of the complex value
• function kfr::indices(const shape<Dims> &, axis_params<VecAxis, N>)
• function kfr::generic::inrange(const T1 &, const T2 &, const T3 &)
• function kfr::generic::interleave(const univector2d<Tin, Tag1, Tag2> &) Interleaves and converts audio samples
• function kfr::generic::interleave(E1 &&, E2 &&)
• function kfr::generic::interleave(Tout *, const Tin **, size_t, size_t) Interleaves and converts audio samples
• function kfr::generic::interleave(univector<Tout, Tag1> &, const univector2d<Tin, Tag2, Tag3> &) Interleaves and converts audio samples
• function kfr::generic::ipow(E1 &&, E2 &&)
• function kfr::generic::irealdft(const univector<complex<T>, Tag> &) Permorms Real Inverse DFT using cached plan
• function kfr::generic::iround(const T1 &) Returns the nearest integer value to x, as an integer type.
• function kfr::generic::iround(E1 &&)
• function kfr::is_single_codec(audiofile_container) Checks if a container supports a single codec.
• function kfr::generic::isawtooth(const T1 &)
• function kfr::generic::isawtooth(E1 &&)
• function kfr::generic::isawtoothnorm(const T1 &)
• function kfr::generic::isawtoothnorm(E1 &&)
• function kfr::generic::isfinite(const vec<T, N> &)
• function kfr::generic::isinf(const vec<T, N> &)
• function kfr::generic::isnan(const vec<T, N> &)
• function kfr::generic::isnegative(const vec<T, N> &)
• function kfr::generic::ispositive(const vec<T, N> &)
• function kfr::generic::isreal(const complex<T> &) Returns mask with true for real elements
• function kfr::generic::iszero(const vec<T, N> &)
• function kfr::generic::itrunc(const T1 &) Returns the truncated integer part of x, as an integer type.
• function kfr::generic::itrunc(E1 &&)

J¶

• function kfr::generic::jaehne_arg(size_t)
• function kfr::generic::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¶

• function kfr_allocate_aligned(size_t, size_t) Allocates memory with specified alignment (must be a power of two).
• function kfr_allocate(size_t) Allocates memory of specified size with default alignment (64 bytes).
• function kfr_current_arch() Returns the current architecture in use.
• function kfr_dct_create_plan_f32(size_t) Create a DCT-II plan (Single precision).
• function kfr_dct_create_plan_f64(size_t) Create a DCT-II plan (Double precision).
• function kfr_dct_delete_plan_f32(KFR_DCT_PLAN_F32 *) Delete a DCT plan.
• function kfr_dct_delete_plan_f64(KFR_DCT_PLAN_F64 *) Delete a DCT plan.
• function kfr_dct_dump_f32(KFR_DCT_PLAN_F32 *) Dump details of the DCT plan to stdout for inspection.
• function kfr_dct_dump_f64(KFR_DCT_PLAN_F64 *) Dump details of the DCT plan to stdout for inspection.
• function kfr_dct_execute_f32(KFR_DCT_PLAN_F32 *, kfr_f32 *, const kfr_f32 *, uint8_t *) Execute DCT-II on in and write the result to out.
• function kfr_dct_execute_f64(KFR_DCT_PLAN_F64 *, kfr_f64 *, const kfr_f64 *, uint8_t *) Execute DCT-II on in and write the result to out.
• function kfr_dct_execute_inverse_f32(KFR_DCT_PLAN_F32 *, kfr_f32 *, const kfr_f32 *, uint8_t *) Execute inverse DCT-II (aka DCT-III) on in and write the result to out.
• function kfr_dct_execute_inverse_f64(KFR_DCT_PLAN_F64 *, kfr_f64 *, const kfr_f64 *, uint8_t *) Execute inverse DCT-II (aka DCT-III) on in and write the result to out.
• function kfr_dct_get_size_f32(KFR_DCT_PLAN_F32 *) Get the size of a DCT plan.
• function kfr_dct_get_size_f64(KFR_DCT_PLAN_F64 *) Get the size of a DCT plan.
• function kfr_dct_get_temp_size_f32(KFR_DCT_PLAN_F32 *) Get temporary (scratch) buffer size for DCT plan.
• function kfr_dct_get_temp_size_f64(KFR_DCT_PLAN_F64 *) Get temporary (scratch) buffer size for DCT plan.
• function kfr_deallocate(void *) Deallocates memory.
• function kfr_dft_create_2d_plan_f32(size_t, size_t) Create a 2D complex DFT plan (Single precision).
• function kfr_dft_create_2d_plan_f64(size_t, size_t) Create a 2D complex DFT plan (Double precision).
• function kfr_dft_create_3d_plan_f32(size_t, size_t, size_t) Create a 3D complex DFT plan (Single precision).
• function kfr_dft_create_3d_plan_f64(size_t, size_t, size_t) Create a 3D complex DFT plan (Double precision).
• function kfr_dft_create_md_plan_f32(size_t, const unsigned int *) Create an N-dimensional complex DFT plan (Single precision).
• function kfr_dft_create_md_plan_f64(size_t, const unsigned int *) Create an N-dimensional complex DFT plan (Double precision).
• function kfr_dft_create_plan_f32(size_t) Create a complex DFT plan (Single precision).
• function kfr_dft_create_plan_f64(size_t) Create a complex DFT plan (Double precision).
• function kfr_dft_delete_plan_f32(KFR_DFT_PLAN_F32 *) Delete a complex DFT plan.
• function kfr_dft_delete_plan_f64(KFR_DFT_PLAN_F64 *) Delete a complex DFT plan.
• function kfr_dft_dump_f32(KFR_DFT_PLAN_F32 *) Dump details of the DFT plan to stdout for inspection.
• function kfr_dft_dump_f64(KFR_DFT_PLAN_F64 *) Dump details of the DFT plan to stdout for inspection.
• function kfr_dft_execute_f32(KFR_DFT_PLAN_F32 *, kfr_c32 *, const kfr_c32 *, uint8_t *) Execute the complex forward DFT on in and write the result to out.
• function kfr_dft_execute_f64(KFR_DFT_PLAN_F64 *, kfr_c64 *, const kfr_c64 *, uint8_t *) Execute the complex forward DFT on in and write the result to out.
• function kfr_dft_execute_inverse_f32(KFR_DFT_PLAN_F32 *, kfr_c32 *, const kfr_c32 *, uint8_t *) Execute the inverse complex DFT on in and write the result to out for in-place execution.
• function kfr_dft_execute_inverse_f64(KFR_DFT_PLAN_F64 *, kfr_c64 *, const kfr_c64 *, uint8_t *) Execute the inverse complex DFT on in and write the result to out.
• function kfr_dft_get_size_f32(KFR_DFT_PLAN_F32 *) Get the size of the DFT plan, in complex numbers.
• function kfr_dft_get_size_f64(KFR_DFT_PLAN_F64 *) Get the size of the DFT plan, in complex numbers.
• function kfr_dft_get_temp_size_f32(KFR_DFT_PLAN_F32 *) Get temporary (scratch) buffer size for DFT plan.
• function kfr_dft_get_temp_size_f64(KFR_DFT_PLAN_F64 *) Get temporary (scratch) buffer size for DFT plan.
• function kfr_dft_real_create_2d_plan_f32(size_t, size_t, kfr_bool)
• function kfr_dft_real_create_2d_plan_f64(size_t, size_t, int)
• function kfr_dft_real_create_3d_plan_f32(size_t, size_t, size_t, kfr_bool)
• function kfr_dft_real_create_3d_plan_f64(size_t, size_t, size_t, int)
• function kfr_dft_real_create_md_plan_f32(size_t, const unsigned int *, kfr_bool)
• function kfr_dft_real_create_md_plan_f64(size_t, const unsigned int *, int)
• function kfr_dft_real_create_plan_f32(size_t, KFR_DFT_PACK_FORMAT) Create a real DFT plan (Single precision).
• function kfr_dft_real_create_plan_f64(size_t, KFR_DFT_PACK_FORMAT) Create a real DFT plan (Double precision).
• function kfr_dft_real_delete_plan_f32(KFR_DFT_REAL_PLAN_F32 *) Delete a real DFT plan.
• function kfr_dft_real_delete_plan_f64(KFR_DFT_REAL_PLAN_F64 *) Delete a real DFT plan.
• function kfr_dft_real_dump_f32(KFR_DFT_REAL_PLAN_F32 *) Dump details of the real DFT plan to stdout for inspection.
• function kfr_dft_real_dump_f64(KFR_DFT_REAL_PLAN_F64 *) Dump details of the real DFT plan to stdout for inspection.
• function kfr_dft_real_execute_f32(KFR_DFT_REAL_PLAN_F32 *, kfr_c32 *, const kfr_f32 *, uint8_t *) Execute real DFT on in and write the result to out
• function kfr_dft_real_execute_f64(KFR_DFT_REAL_PLAN_F64 *, kfr_c64 *, const kfr_f64 *, uint8_t *) Execute real DFT on in and write the result to out.
• function kfr_dft_real_execute_inverse_f32(KFR_DFT_REAL_PLAN_F32 *, kfr_f32 *, const kfr_c32 *, uint8_t *) Execute inverse real DFT on in and write the result to out.
• function kfr_dft_real_execute_inverse_f64(KFR_DFT_REAL_PLAN_F64 *, kfr_f64 *, const kfr_c64 *, uint8_t *) Execute inverse real DFT on in and write the result to out.
• function kfr_dft_real_get_size_f32(KFR_DFT_REAL_PLAN_F32 *) Get the size of a real DFT plan.
• function kfr_dft_real_get_size_f64(KFR_DFT_REAL_PLAN_F64 *) Get the size of a real DFT plan.
• function kfr_dft_real_get_temp_size_f32(KFR_DFT_REAL_PLAN_F32 *) Get temporary (scratch) buffer size for real DFT plan (Single precision).
• function kfr_dft_real_get_temp_size_f64(KFR_DFT_REAL_PLAN_F64 *) Get temporary (scratch) buffer size for real DFT plan (Double precision).
• function kfr_enabled_archs() Returns the list of enabled architectures as a string.
• function kfr_filter_create_convolution_plan_f32(const kfr_f32 *, size_t, size_t) Create a convolution filter plan (Single precision).
• function kfr_filter_create_convolution_plan_f64(const kfr_f64 *, size_t, size_t) Create a convolution filter plan (Double precision).
• function kfr_filter_create_fir_plan_f32(const kfr_f32 *, size_t) Create a FIR filter plan (Single precision).
• function kfr_filter_create_fir_plan_f64(const kfr_f64 *, size_t) Create a FIR filter plan (Double precision).
• function kfr_filter_create_iir_plan_f32(const kfr_f32 *, size_t) Create a IIR filter plan (Single precision).
• function kfr_filter_create_iir_plan_f64(const kfr_f64 *, size_t) Create a IIR filter plan (Double precision).
• function kfr_filter_delete_plan_f32(KFR_FILTER_F32 *) Delete a filter plan.
• function kfr_filter_delete_plan_f64(KFR_FILTER_F64 *) Delete a filter plan.
• function kfr_filter_process_f32(KFR_FILTER_F32 *, kfr_f32 *, const kfr_f32 *, size_t) Process input data with a filter.
• function kfr_filter_process_f64(KFR_FILTER_F64 *, kfr_f64 *, const kfr_f64 *, size_t) Process input data with a filter.
• function kfr_filter_reset_f32(KFR_FILTER_F32 *) Reset the internal state of a filter plan, including delay line.
• function kfr_filter_reset_f64(KFR_FILTER_F64 *) Reset the internal state of a filter plan, including delay line.
• function kfr_last_error() Returns the last error message.
• function kfr_version() Returns the library version as an integer.
• function kfr_version_string() Returns the library version as a string.

L¶

• function kfr::lambda_generator(Fn &&)
• function kfr::lambda(Fn &&, cbool_t<RandomAccess>)
• function kfr::generic::le(E1 &&, E2 &&)
• function kfr::generic::less(const T1 &, const T2 &)
• function kfr::generic::lessorequal(const T1 &, const T2 &)
• function kfr::library_version_audio()
• function kfr::library_version_codecs() Returns a comma-separated list of enabled audio codecs.
• function kfr::library_version_dft()
• function kfr::library_version_dsp()
• function kfr::library_version_io()
• function kfr::generic::linear(M, T, T) Linear interpolation.
• function kfr::linspace(T1, T2, size_t, bool, cbool_t<truncated>) Returns evenly spaced numbers over a specified interval.
• function kfr::load_from_npy(tensor<T, Dims> &, Fn &&) Loads a tensor from .npy format using a custom read callback.
• function kfr::log10(E1 &&) Returns the common (base-10) logarithm of the x. Accepts and returns expressions.
• function kfr::log2(E1 &&) Returns the binary (base-2) logarithm of the x. Accepts and returns expressions.
• function kfr::log_fmadd(E1 &&, E2 &&, E3 &&) Returns log(x) * m + a. Accepts and returns expressions.
• function kfr::logb(E1 &&) Returns the rounded binary (base-2) logarithm of the x. Version that accepts and returns expressions.
• function kfr::log(E1 &&) Returns the natural logarithm of the x. Accepts and returns expressions.
• function kfr::logm(E1 &&, E2 &&) Returns log(x) * y. Accepts and returns expressions.
• function kfr::logn(E1 &&, E2 &&) Returns the logarithm of the x with base y. Accepts and returns expressions.
• function kfr::generic::loudness_to_energy(T)
• function kfr::generic::lt(E1 &&, E2 &&)

M¶

• function kfr::make_array_ref(Container &&)
• function kfr::make_array_ref(T *, std::size_t)
• function kfr::generic::make_complex(const vec<T1, N> &, const vec<T2, N> &) Constructs complex value from real and imaginary parts
• function kfr::generic::make_complex(E1 &&, E2 &&) Constructs complex value from real and imaginary parts
• function kfr::generic::make_complex(T1, T2) Constructs complex value from real and imaginary parts
• function kfr::generic::make_kfilter(int)
• function kfr::make_memory_finalizer(Fn &&)
• function kfr::make_range(T, T) Make iterable range object
• function kfr::make_range(T, T, D) Make iterable range object with step
• function kfr::make_resource(E &&)
• function kfr::make_univector(const Container &) Creates univector from a container (must have data() and size() methods)
• function kfr::make_univector(const T (&)[N]) Creates univector from a sized array
• function kfr::make_univector(const T *, size_t) Creates univector from data and size
• function kfr::make_univector(Container &) Creates univector from a container (must have data() and size() methods)
• function kfr::make_univector(T (&)[N]) Creates univector from a sized array
• function kfr::make_univector(T *, size_t) Creates univector from data and size
• function kfr::generic::matrix_halfsum_halfdiff()
• function kfr::generic::matrix_sum_diff()
• function kfr::generic::matrix_transpose(T *, const T *, shape<Dims>) Transposes a matrix (supports scalar and compound types).
• function kfr::generic::max(E1 &&, E2 &&) Returns the greater of two values. Accepts and returns expressions.
• function kfr::generic::maxof(const E1 &) Returns the greatest of all the elements in x.
• function kfr::generic::mean(const E1 &) Returns the arithmetic mean of all the elements in x.
• function kfr::generic::min(E1 &&, E2 &&) Returns the smaller of two values. Accepts and returns expressions.
• function kfr::generic::minof(const E1 &) Returns the smallest of all the elements in x.
• function kfr::generic::mixdown_stereo(Left &&, Right &&, const f64x2x2 &) Returns template expression that returns the vector of length 2 containing mix of the left and right channels
• function kfr::generic::mixdown(E &&...) Returns template expression that returns the sum of all the inputs
• function kfr::generic::mix(E1 &&, E2 &&, E3 &&)
• function kfr::generic::mixs(E1 &&, E2 &&, E3 &&)
• function kfr::generic::modzerobessel(const T1 &) Computes the modified zeroth-order Bessel function of the first kind. This function calculates I₀(x), the modified Bessel function of the first kind with order zero, for the given input value.
• function kfr::modzerobessel(E1 &&)
• function kfr::generic::moving_sum(E1 &&) Returns template expression that performs moving sum on the input
• function kfr::generic::moving_sum(E1 &&, size_t) Returns template expression that performs moving sum on the input
• function kfr::generic::moving_sum(E1 &&, std::reference_wrapper<moving_sum_state<U, Tag>>) Returns template expression that performs moving sum on the input
• function kfr::generic::moving_sum(moving_sum_state<U, STag> &, E1 &&) Returns template expression that performs moving sum on the input
• function kfr::generic::mul(E &&...) Returns template expression that returns product of all the arguments passed to a function.
• function kfr::compiletime::mulsign(T, T)

N¶

• function kfr::generic::nearest(M, T, T) Nearest-neighbor interpolation.
• function kfr::generic::ne(E1 &&, E2 &&)
• function kfr::generic::note_to_hertz(const T1 &)
• function kfr::generic::note_to_hertz(E1 &&)
• function kfr::generic::notequal(const T1 &, const T2 &)

O¶

• function kfr::ones()
• function kfr::open_file_for_appending(const filepath &) Opens typed file for appending
• function kfr::open_file_for_appending(const std::string &) Opens typed file for appending
• function kfr::open_file_for_reading(const filepath &) Opens typed file for reading
• function kfr::open_file_for_reading(const std::string &) Opens typed file for reading
• function kfr::open_file_for_writing(const filepath &) Opens typed file for writing
• function kfr::open_file_for_writing(const std::string &) Opens typed file for writing
• function kfr::operator==(const data_allocator<T1> &, const data_allocator<T2> &)
• function kfr::operator!=(const data_allocator<T1> &, const data_allocator<T2> &)
• function kfr::operator==(const univector<T, T1> &, const univector<T, T2> &)
• function kfr::operator!=(const univector<T, T1> &, const univector<T, T2> &)
• function kfr::generic::operator-(E1 &&)
• function kfr::generic::operator~(E1 &&)
• function kfr::generic::operator+(E1 &&, E2 &&)
• function kfr::generic::operator-(E1 &&, E2 &&)
• function kfr::generic::operator*(E1 &&, E2 &&)
• function kfr::generic::operator/(E1 &&, E2 &&)
• function kfr::generic::operator%(E1 &&, E2 &&)
• function kfr::generic::operator&(E1 &&, E2 &&)
• function kfr::generic::operator|(E1 &&, E2 &&)
• function kfr::generic::operator^(E1 &&, E2 &&)
• function kfr::generic::operator<<(E1 &&, E2 &&)
• function kfr::generic::operator>>(E1 &&, E2 &&)
• function kfr::generic::operator+=(E1 &&, E2 &&)
• function kfr::generic::operator-=(E1 &&, E2 &&)
• function kfr::generic::operator*=(E1 &&, E2 &&)
• function kfr::generic::operator/=(E1 &&, E2 &&)
• function kfr::generic::operator%=(E1 &&, E2 &&)
• function kfr::generic::operator|=(E1 &&, E2 &&)
• function kfr::generic::operator&=(E1 &&, E2 &&)
• function kfr::generic::operator^=(E1 &&, E2 &&)
• function kfr::generic::operator<<=(E1 &&, E2 &&)
• function kfr::generic::operator>>=(E1 &&, E2 &&)

P¶

• function kfr::generic::pack(Args &&...)
• function kfr::padded(Arg &&, T)
• function kfr::generic::partial_mask(size_t)
• function kfr::generic::partial_mask(size_t, vec_shape<T, N>)
• function kfr::perfplot_save(const std::string &, T1 &&, T2 &&, const std::string &)
• function kfr::perfplot_show(const std::string &, T1 &&, T2 &&, const std::string &)
• function kfr::generic::phasor(std::type_identity_t<T>)
• function kfr::generic::phasor(std::type_identity_t<T>, std::type_identity_t<T>, std::type_identity_t<T>)
• function kfr::placeholder(csize_t<Key>)
• function kfr::plot_save(const std::string &, const T &, const std::string &) Plot data using python and save to file
• function kfr::plot_show(const std::string &, const char *, const std::string &)
• function kfr::plot_show(const std::string &, const std::string &, const std::string &)
• function kfr::plot_show(const std::string &, const T &, const std::string &) Plot data using python
• function kfr::generic::polar(const T1 &) Converts complex number to polar
• function kfr::polar(E1 &&) Returns template expression that converts complex number to polar
• function kfr::generic::pow2(E1 &&)
• function kfr::generic::pow3(E1 &&)
• function kfr::generic::pow4(E1 &&)
• function kfr::generic::pow5(E1 &&)
• function kfr::pow(E1 &&, E2 &&) Returns the x raised to the given power y. Accepts and returns expressions.
• function kfr::generic::power_to_dB(const T1 &)
• function kfr::generic::power_to_dB(E1 &&)
• function kfr::generic::process(Out &&, In &&, shape<0>, shape<0>, csize_t<gw>)
• function kfr::generic::process(Out &&, In &&, shape<outdims>, shape<outdims>, csize_t<gw>)
• function kfr::generic::product(const E1 &) Returns the product of all the elements in x.
• function kfr::python_prologue()

R¶

• function kfr::generic::random_bits(random_state &) Generates more than 16 bytes of random data.
• function kfr::generic::random_init() Initializes the random number generator state using the CPU cycle counter.
• function kfr::generic::random_init(u32, u32, u32, u32) Initializes the random number generator with four 32-bit seed values.
• function kfr::generic::random_init(u64, u64) Initializes the random number generator with two 64-bit seed values.
• function kfr::generic::random_next(random_state &) Advances the internal state of the pseudo-random number generator.
• function kfr::generic::random_normal(random_state &, T, T) Generates N normally distributed (Gaussian) random values using Box-Muller transform.
• function kfr::generic::random_range(random_state &, T, T) Generates random values uniformly distributed in the range [min, max) for integral types.
• function kfr::generic::random_uniform(random_state &) Generates a vector of uniformly distributed floating-point numbers in [0.0, 1.0).
• function kfr::generic::randommantissa(random_state &)
• function kfr::generic::randommantissa(random_state &)
• function kfr::generic::rawsawtooth(const T1 &)
• function kfr::generic::rawsawtooth(E1 &&)
• function kfr::generic::rawsine(const T1 &)
• function kfr::generic::rawsine(E1 &&)
• function kfr::generic::rawsquare(const T1 &)
• function kfr::generic::rawsquare(E1 &&)
• function kfr::generic::rawtriangle(const T1 &)
• function kfr::generic::rawtriangle(E1 &&)
• function kfr::read_audiofile_header(const file_path &) Reads the header of an audio file.
• function kfr::read_audiofile_header(const std::string &) Creates an audio decoder from a file header.
• function kfr::generic::read_group(const T *, size_t)
• function kfr::generic::read(const T *)
• function kfr::generic::real(const complex<T> &) Returns the real part of the complex value
• function kfr::generic::real(const T &) Returns the real part of the complex value
• function kfr::generic::real(const vec<complex<T>, N> &) Returns the real part of the complex value
• function kfr::generic::realdft(const univector<T, Tag> &) Performs Real Direct DFT using cached plan
• function kfr::generic::real(E1 &&) Returns the real part of the complex value
• function kfr::generic::rebind(const expression_function<Fn, OldArgs...> &, NewArgs &&...) Construct a new expression using the same function as inand new arguments
• function kfr::generic::rebind(expression_function<Fn, OldArgs...> &&, NewArgs &&...)
• function kfr::generic::reduce(const E1 &, ReduceFn &&, TransformFn &&, FinalFn &&)
• function kfr::reference_dft_md(complex<T> *, const complex<T> *, shape<dynamic_shape>, bool, size_t, size_t) Performs Multidimensional Complex DFT using reference implementation (slow, used for testing)
• function kfr::reference_dft_md(complex<T> *, const T *, shape<dynamic_shape>, bool, size_t, size_t) Performs Multidimensional Direct Real DFT using reference implementation (slow, used for testing)
• function kfr::reference_dft(complex<T> *, const complex<T> *, size_t, bool, size_t, size_t) Performs Complex DFT using reference implementation (slow, used for testing)
• function kfr::reference_dft(complex<T> *, const T *, size_t, size_t, size_t) Performs Direct Real DFT using reference implementation (slow, used for testing)
• function kfr::generic::rem(const vec<T, N> &, const vec<T, N> &) Returns the element-wise floating-point remainder of vectors x and y.
• function kfr::generic::render(Expr &&) Converts an expression to univector
• function kfr::generic::render(Expr &&, csize_t<Size>) Converts an expression to univector
• function kfr::generic::render(Expr &&, size_t, size_t) Converts an expression to univector
• function kfr::generic::resampler(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>)
• function kfr::reshape(Arg &&, const shape<OutDims> &)
• function kfr::reverse(Arg &&)
• function kfr::generic::rms(const E1 &) Returns the root mean square of all the elements in x.
• function kfr::root(E1 &&, E2 &&) Returns the real nth root of the x. Accepts and returns expressions.
• function kfr::generic::round(const T1 &) Returns the nearest integer value to x.
• function kfr::generic::round(E1 &&)

S¶

• function kfr::safe_cast(const InType &)
• function kfr::generic::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 kfr::samples_load(audio_sample_type, fbase *const *, const std::byte *, size_t, size_t, bool) Loads interleaved audio samples based on sample type.
• function kfr::samples_load(audio_sample_type, fbase *, const std::byte *, size_t, bool) Loads audio samples based on sample type.
• function kfr::samples_load(fbase *const *, const Tin *, size_t, size_t, bool) Loads interleaved audio samples into a planar floating-point buffer.
• function kfr::samples_load(fbase *, const Tin *, size_t, bool) Loads audio samples into a floating-point buffer.
• function kfr::samples_store(audio_sample_type, std::byte *, const fbase *const *, size_t, size_t, bool) Stores interleaved audio samples based on sample type.
• function kfr::samples_store(audio_sample_type, std::byte *, const fbase *const *, size_t, size_t, const audio_quantization &, bool) Stores interleaved audio samples based on sample type with quantization.
• function kfr::samples_store(audio_sample_type, std::byte *, const fbase *, size_t, const audio_quantization &, bool) Stores audio samples based on sample type with quantization.
• function kfr::samples_store(Tout *, const fbase *const *, size_t, size_t, bool) Stores planar floating-point samples into a interleaved buffer.
• function kfr::samples_store(Tout *, const fbase *const *, size_t, size_t, const audio_quantization &, bool) Stores planar floating-point samples into an interleaved buffer with quantization.
• function kfr::samples_store(Tout *, const fbase *, size_t, const audio_quantization &, bool) Stores floating-point samples into a buffer with quantization.
• function kfr::generic::satadd(const T1 &, const T2 &) Adds two numeric values using saturation arithmetic.
• function kfr::generic::satadd(E1 &&, E2 &&) Creates an expression that adds two arguments using saturation
• function kfr::generic::satsub(const T1 &, const T2 &) Subtracts two numeric values using saturation arithmetic.
• function kfr::generic::satsub(E1 &&, E2 &&) Creates an expression that subtracts two arguments using saturation
• function kfr::generic::saturate_I(const T1 &)
• function kfr::generic::saturate_I(E1 &&)
• function kfr::generic::saturate_II(const T1 &)
• function kfr::generic::saturate_II(E1 &&)
• function kfr::save_to_npy(const tensor<T, Dims> &, Fn &&) Saves a tensor to .npy format using a custom write callback.
• function kfr::generic::sawtooth(const T1 &)
• function kfr::generic::sawtooth(E1 &&)
• function kfr::generic::sawtoothnorm(const T1 &)
• function kfr::generic::sawtoothnorm(E1 &&)
• function kfr::scalar(T)
• function kfr::generic::scatter_stride(T *, const vec<T, N> &, size_t)
• function kfr::generic::scatter(const T *, const vec<T, N> &)
• function kfr::generic::scatter(T *, const vec<IT, N> &, const vec<T, Nout> &)
• function kfr::compiletime::select(bool, T, T)
• function kfr::generic::select(E1 &&, E2 &&, E3 &&) Returns template expression that returns x if m is true, otherwise return y. Order of the arguments is same as in ternary operator.
• function kfr::sequence(const Ts &...)
• function kfr::generic::set_elements(const expression_cast<T, Arg> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(const expression_handle<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(const expression_slice<Arg> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(const tensor<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(expression_fixshape<Arg, Shape> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(expression_function<fn::packtranspose, Args...> &, shape<Tr::dims>, axis_params<Axis, N>, const std::type_identity_t<vec<typename Tr::value_type, N>> &)
• function kfr::generic::set_elements(expression_reshape<Arg, outdims> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(expression_reverse<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::set_elements(strided_channel<T> &, const shape<1> &, const axis_params<0, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(T &, const shape<0> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::set_elements(univector<T, Tag> &, const shape<1> &, const axis_params<0, N> &, const std::type_identity_t<vec<T, N>> &)
• function kfr::generic::short_fir(E1 &&, const univector<T, TapCount> &) Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
• function kfr::generic::short_fir(E1 &&, std::reference_wrapper<short_fir_state<TapCount, T, U>>) Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
• function kfr::generic::short_fir(short_fir_state<InternalTapCount, T, U> &, E1 &&) Returns template expression that applies FIR filter to the input (count of coefficients must be in range 2..32)
• function kfr::generic::shufflevector(const vec<complex<T>, N> &, csizes_t<indices...>)
• function kfr::generic::shufflevectors(const vec<complex<T>, N> &, const vec<T, N> &, csizes_t<indices...>)
• function kfr::sinc(E1 &&) Returns the sinc function of x. Accepts and returns expressions.
• function kfr::sincosdeg(E1 &&) Returns the trigonometric sine of the even elements of the x and cosine of the odd elements. x must be expressed in degrees. Accepts and returns expressions.
• function kfr::sincos(E1 &&) Returns the trigonometric sine of the even elements of the x and cosine of the odd elements. x must be a vector. Accepts and returns expressions.
• function kfr::sindeg(E1 &&) Returns the trigonometric sine of the x (expressed in degrees). Accepts and returns expressions.
• function kfr::sin(E1 &&) Returns the trigonometric sine of x. Accepts and returns expressions.
• function kfr::generic::sine(const T1 &)
• function kfr::generic::sine(E1 &&)
• function kfr::generic::sinenorm(const T1 &)
• function kfr::generic::sinenorm(E1 &&)
• function kfr::generic::sinh(const T1 &) Returns the hyperbolic sine of the x
• function kfr::generic::sinhcosh(const T1 &) Returns the hyperbolic sine of the even elements of the x and the hyperbolic cosine of the odd elements of the x
• function kfr::sinhcosh(E1 &&) Returns template expression that returns the hyperbolic sine of the even elements of the x and the hyperbolic cosine of the odd elements of the x
• function kfr::sinh(E1 &&) Returns template expression that returns the hyperbolic sine of the x
• function kfr::generic::sink(E &&) Read the expressionthrough the whole range.
• function kfr::compiletime::sin(T)
• function kfr::size_add(size_t, size_t)
• function kfr::size_min(size_t)
• function kfr::size_min(size_t, size_t, Ts...)
• function kfr::size_of_shape(const shape<dims> &)
• function kfr::size_sub(size_t, size_t)
• function kfr::slice(Arg &&, std::type_identity_t<shape<Dims>>, std::type_identity_t<shape<Dims>>)
• function kfr::generic::sort(const vec<T, N> &) Sort the elements in the vector in ascending order
• function kfr::generic::sortdesc(const vec<T, N> &) Sort the elements in the vector in descending order
• function kfr::generic::sqr(E1 &&) Returns template expression that returns square of x.
• function kfr::sqrt(E1 &&) Returns template expression that returns the positive square root of the x. \(\sqrt{x}\)
• function kfr::generic::square(const T1 &)
• function kfr::generic::square(E1 &&)
• function kfr::generic::squarenorm(const T1 &)
• function kfr::generic::squarenorm(E1 &&)
• function kfr::generic::stddev(const E1 &) Computes the standard deviation of the given expression.
• function kfr::generic::sub(E1 &&, E2 &&)
• function kfr::substitute(const internal_generic::anything &, Args &&...)
• function kfr::substitute(expression_handle<T, Dims> &, expression_handle<T, Dims>, csize_t<Key>)
• function kfr::substitute(expression_placeholder<T, Dims, Key> &, expression_handle<T, Dims>, csize_t<Key>)
• function kfr::substitute(expression_with_arguments<Args...> &, expression_handle<T, Dims>, csize_t<Key>)
• function kfr::generic::sum(const E1 &) Returns the sum of all the elements in x.
• function kfr::generic::sumsqr(const E1 &) Returns the sum of squares of all the elements in x.
• function kfr::generic::swept_arg(size_t)
• function kfr::generic::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.
• function kfr::symmlinspace(T, size_t, cbool_t<truncated>) Returns evenly spaced numbers over a specified interval.

T¶

• function kfr::tall()
• function kfr::generic::tan(const T1 &) Computes the tangent of the input (in radians).
• function kfr::generic::tandeg(const T1 &) Computes the tangent of the input (in degrees).
• function kfr::tandeg(E1 &&)
• function kfr::tan(E1 &&)
• function kfr::generic::tanh(const T1 &) Returns the hyperbolic tangent of the x
• function kfr::tanh(E1 &&) Returns template expression that returns the hyperbolic tangent of the x
• function kfr::tensor_from_container(Container)
• function kfr::generic::to_filter(E &&) Converts expression with placeholder to filter. Placeholder and filter must have the same type
• function kfr::to_filter(expression_handle<T, 1> &&) Converts expression with placeholder to filter. Placeholder and filter must have the same type
• function kfr::to_handle(E &) Converts the given expression into an opaque object. This overload takes reference to the expression.
• function kfr::to_handle(E &&) Converts the given expression into an opaque object. This overload takes ownership of the expression (Move semantics).
• function kfr::generic::to_sos(const zpk &)
• function kfr::to_string(audiofile_error) Converts an audiofile_error to its string representation.
• function kfr::generic::to_vec(const shape<Dims> &)
• function kfr::generic::to_vec(const std::array<T, N> &)
• function kfr::generic::tprocess_body(Out &&, In &&, size_t, size_t, size_t, shape<outdims>, shape<indims>)
• function kfr::generic::trace(E1 &&) Returns template expression that prints all processed values for debug
• function kfr::trange(std::optional<signed_index_t>, std::optional<signed_index_t>, std::optional<signed_index_t>)
• function kfr::generic::trender(const E &)
• function kfr::generic::trender(const E &, shape<Traits::dims>)
• function kfr::generic::triangle(const T1 &)
• function kfr::generic::triangle(E1 &&)
• function kfr::generic::trianglenorm(const T1 &)
• function kfr::generic::trianglenorm(E1 &&)
• function kfr::truncate(Arg &&, std::type_identity_t<shape<Dims>>)
• function kfr::generic::trunc(const T1 &) Returns the integer part of x by removing its fractional part.
• function kfr::generic::trunc(E1 &&)
• function kfr::compiletime::trunc(T)
• function kfr::tstart(signed_index_t, signed_index_t)
• function kfr::tstep(signed_index_t)
• function kfr::tstop(signed_index_t, signed_index_t)

U¶

• function kfr::generic::unitimpulse() Returns expression template that generates a unit impulse
• function kfr::generic::unpack(E &&...)
• function kfr::generic::upsample2(E1 &&)
• function kfr::generic::upsample4(E1 &&)

V¶

• function kfr::generic::variance(const E1 &) Computes the variance of the given input expression.
• function kfr::generic::vec<T, N>(const value_type *, cbool_t<aligned>)

W¶

• function kfr::generic::waveshaper_hardclip(E1 &&, double)
• function kfr::generic::waveshaper_poly(E1 &&, fbase, fbase, Cs...)
• function kfr::generic::waveshaper_saturate_I(E1 &&, double)
• function kfr::generic::waveshaper_saturate_II(E1 &&, double)
• function kfr::generic::waveshaper_tanh(E1 &&, double)
• function kfr::generic::window_bartlett_hann(size_t, ctype_t<T>) Returns template expression that generates Bartlett-Hann window of length
• function kfr::generic::window_bartlett(size_t, ctype_t<T>) Returns template expression that generates Bartlett window of length
• function kfr::generic::window_blackman_harris(size_t, window_symmetry, ctype_t<T>) Returns template expression that generates Blackman-Harris window of length
• function kfr::generic::window_blackman(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates Blackman window of lengthwhere α =
• function kfr::generic::window_bohman(size_t, ctype_t<T>) Returns template expression that generates Bohman window of length
• function kfr::generic::window_cosine_np(size_t, ctype_t<T>) Returns template expression that generates Cosine window (numpy compatible) of length
• function kfr::generic::window_cosine(size_t, ctype_t<T>) Returns template expression that generates Cosine window of length
• function kfr::generic::window_flattop(size_t, ctype_t<T>) Returns template expression that generates Flat top window of length
• function kfr::generic::window_gaussian(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates Gaussian window of lengthwhere α =
• function kfr::generic::window_hamming(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates Hamming window of lengthwhere α =
• function kfr::generic::window_hann(size_t, ctype_t<T>) Returns template expression that generates Hann window of length
• function kfr::generic::window_kaiser(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates Kaiser window of lengthwhere β =
• function kfr::generic::window_lanczos(size_t, ctype_t<T>) Returns template expression that generates Lanczos window of length
• function kfr::generic::window_planck_taper(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates Planck-taper window of length
• function kfr::generic::window_rectangular(size_t, ctype_t<T>) Returns template expression that generates Rrectangular window of length
• function kfr::generic::window_triangular(size_t, ctype_t<T>) Returns template expression that generates Triangular window of length
• function kfr::generic::window_tukey(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates Tukey window of length(numpy compatible)
• function kfr::generic::window(size_t, cval_t<window_type, type>, std::type_identity_t<T>, window_symmetry, ctype_t<T>)
• function kfr::generic::window(size_t, window_type, std::type_identity_t<T>, window_symmetry, ctype_t<T>)
• function kfr::generic::write_group(T *, size_t, const vec<T, group * count * N> &)
• function kfr::generic::write(T *, const vec<T, N> &)
• function kfr::generic::write(value_type *, cbool_t<aligned>)

Z¶

• function kfr::zeros()